/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'regional';
  @endpointMap = {
    ap-northeast-2-pop = 'hbase.aliyuncs.com',
    ap-south-1 = 'hbase.aliyuncs.com',
    ap-southeast-2 = 'hbase.aliyuncs.com',
    cn-beijing-finance-1 = 'hbase.aliyuncs.com',
    cn-beijing-finance-pop = 'hbase.aliyuncs.com',
    cn-beijing-gov-1 = 'hbase.aliyuncs.com',
    cn-beijing-nu16-b01 = 'hbase.aliyuncs.com',
    cn-edge-1 = 'hbase.aliyuncs.com',
    cn-fujian = 'hbase.aliyuncs.com',
    cn-haidian-cm12-c01 = 'hbase.aliyuncs.com',
    cn-hangzhou-bj-b01 = 'hbase.aliyuncs.com',
    cn-hangzhou-internal-prod-1 = 'hbase.aliyuncs.com',
    cn-hangzhou-internal-test-1 = 'hbase.aliyuncs.com',
    cn-hangzhou-internal-test-2 = 'hbase.aliyuncs.com',
    cn-hangzhou-internal-test-3 = 'hbase.aliyuncs.com',
    cn-hangzhou-test-306 = 'hbase.aliyuncs.com',
    cn-hongkong-finance-pop = 'hbase.aliyuncs.com',
    cn-qingdao-nebula = 'hbase.aliyuncs.com',
    cn-shanghai-et15-b01 = 'hbase.aliyuncs.com',
    cn-shanghai-et2-b01 = 'hbase.aliyuncs.com',
    cn-shanghai-inner = 'hbase.aliyuncs.com',
    cn-shanghai-internal-test-1 = 'hbase.aliyuncs.com',
    cn-shenzhen-inner = 'hbase.aliyuncs.com',
    cn-shenzhen-st4-d01 = 'hbase.aliyuncs.com',
    cn-shenzhen-su18-b01 = 'hbase.aliyuncs.com',
    cn-wuhan = 'hbase.aliyuncs.com',
    cn-wulanchabu = 'hbase.aliyuncs.com',
    cn-yushanfang = 'hbase.aliyuncs.com',
    cn-zhangbei = 'hbase.aliyuncs.com',
    cn-zhangbei-na61-b01 = 'hbase.aliyuncs.com',
    cn-zhangjiakou-na62-a01 = 'hbase.aliyuncs.com',
    cn-zhengzhou-nebula-1 = 'hbase.aliyuncs.com',
    eu-west-1-oxs = 'hbase.aliyuncs.com',
    rus-west-1-pop = 'hbase.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('hbase', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model AddUserHdfsInfoRequest {
  clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd5****582s'),
  extInfo?: string(name='ExtInfo', description='This parameter is required.', example='{"dfs.nameservices":"hdfs_test","dfs.ha.namenodes":"nn1,nn2","dfs.namenode.http-address.hdfs_test.nn1":"TEST-xxx1.com:50070","dfs.namenode.http-address.hdfs_test.nn2":"TEST-xxx2.com:50070","dfs.namenode.rpc-address.hdfs_test.nn1":"TEST-xxx1.com:8020","dfs.namenode.rpc-address.hdfs_test.nn2":"TEST-xxx2.com:8020"}'),
}

model AddUserHdfsInfoResponseBody = {
  requestId?: string(name='RequestId', example='FB0B7918-198C-46A8-AB9B-FE15403B1F0A'),
}

model AddUserHdfsInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddUserHdfsInfoResponseBody(name='body'),
}

/**
 * @param request AddUserHdfsInfoRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AddUserHdfsInfoResponse
 */
async function addUserHdfsInfoWithOptions(request: AddUserHdfsInfoRequest, runtime: Util.RuntimeOptions): AddUserHdfsInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.extInfo)) {
    query['ExtInfo'] = request.extInfo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddUserHdfsInfo',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request AddUserHdfsInfoRequest
 * @return AddUserHdfsInfoResponse
 */
async function addUserHdfsInfo(request: AddUserHdfsInfoRequest): AddUserHdfsInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return addUserHdfsInfoWithOptions(request, runtime);
}

model AllocatePublicNetworkAddressRequest {
  clientToken?: string(name='ClientToken', example='83b2b5e117a5b8bce0fae88d90576a84_6452320_82718582'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}

model AllocatePublicNetworkAddressResponseBody = {
  requestId?: string(name='RequestId'),
}

model AllocatePublicNetworkAddressResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AllocatePublicNetworkAddressResponseBody(name='body'),
}

/**
 * @param request AllocatePublicNetworkAddressRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return AllocatePublicNetworkAddressResponse
 */
async function allocatePublicNetworkAddressWithOptions(request: AllocatePublicNetworkAddressRequest, runtime: Util.RuntimeOptions): AllocatePublicNetworkAddressResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AllocatePublicNetworkAddress',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request AllocatePublicNetworkAddressRequest
 * @return AllocatePublicNetworkAddressResponse
 */
async function allocatePublicNetworkAddress(request: AllocatePublicNetworkAddressRequest): AllocatePublicNetworkAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return allocatePublicNetworkAddressWithOptions(request, runtime);
}

model CancelActiveOperationTasksRequest {
  ids?: string(name='Ids', description='This parameter is required.', example='11111,22222'),
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  securityToken?: string(name='SecurityToken'),
}

model CancelActiveOperationTasksResponseBody = {
  ids?: string(name='Ids', example='11111,22222'),
  requestId?: string(name='RequestId', example='AE4F6C34-065F-45AA-F5BN-4B8D816F6305'),
}

model CancelActiveOperationTasksResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CancelActiveOperationTasksResponseBody(name='body'),
}

/**
 * @param request CancelActiveOperationTasksRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CancelActiveOperationTasksResponse
 */
async function cancelActiveOperationTasksWithOptions(request: CancelActiveOperationTasksRequest, runtime: Util.RuntimeOptions): CancelActiveOperationTasksResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.ownerAccount)) {
    query['OwnerAccount'] = request.ownerAccount;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.securityToken)) {
    query['SecurityToken'] = request.securityToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CancelActiveOperationTasks',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CancelActiveOperationTasksRequest
 * @return CancelActiveOperationTasksResponse
 */
async function cancelActiveOperationTasks(request: CancelActiveOperationTasksRequest): CancelActiveOperationTasksResponse {
  var runtime = new Util.RuntimeOptions{};
  return cancelActiveOperationTasksWithOptions(request, runtime);
}

model CheckComponentsVersionRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  components?: string(name='Components', description='This parameter is required.', example='HBASE,HADOOP'),
}

model CheckComponentsVersionResponseBody = {
  components?: {
    component?: [ 
    {
      component?: string(name='Component', example='HBASE'),
      isLatestVersion?: string(name='IsLatestVersion', example='true'),
    }
  ](name='Component')
  }(name='Components'),
  requestId?: string(name='RequestId', example='E3537EB4-1100-41CA-A147-C74CCC8BB12C'),
}

model CheckComponentsVersionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CheckComponentsVersionResponseBody(name='body'),
}

/**
 * @param request CheckComponentsVersionRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CheckComponentsVersionResponse
 */
async function checkComponentsVersionWithOptions(request: CheckComponentsVersionRequest, runtime: Util.RuntimeOptions): CheckComponentsVersionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.components)) {
    query['Components'] = request.components;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CheckComponentsVersion',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CheckComponentsVersionRequest
 * @return CheckComponentsVersionResponse
 */
async function checkComponentsVersion(request: CheckComponentsVersionRequest): CheckComponentsVersionResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkComponentsVersionWithOptions(request, runtime);
}

model CloseBackupRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
}

model CloseBackupResponseBody = {
  requestId?: string(name='RequestId', example='F1A11940-0C34-4385-864F-A01E29B55F6A'),
}

model CloseBackupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CloseBackupResponseBody(name='body'),
}

/**
 * @param request CloseBackupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CloseBackupResponse
 */
async function closeBackupWithOptions(request: CloseBackupRequest, runtime: Util.RuntimeOptions): CloseBackupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CloseBackup',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CloseBackupRequest
 * @return CloseBackupResponse
 */
async function closeBackup(request: CloseBackupRequest): CloseBackupResponse {
  var runtime = new Util.RuntimeOptions{};
  return closeBackupWithOptions(request, runtime);
}

model ConvertInstanceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
  duration?: int32(name='Duration', example='7'),
  payType?: string(name='PayType', example='Prepaid'),
  pricingCycle?: string(name='PricingCycle', example='month'),
}

model ConvertInstanceResponseBody = {
  orderId?: long(name='OrderId', example='54124548879'),
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}

model ConvertInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ConvertInstanceResponseBody(name='body'),
}

/**
 * @param request ConvertInstanceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ConvertInstanceResponse
 */
async function convertInstanceWithOptions(request: ConvertInstanceRequest, runtime: Util.RuntimeOptions): ConvertInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.duration)) {
    query['Duration'] = request.duration;
  }
  if (!Util.isUnset(request.payType)) {
    query['PayType'] = request.payType;
  }
  if (!Util.isUnset(request.pricingCycle)) {
    query['PricingCycle'] = request.pricingCycle;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ConvertInstance',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ConvertInstanceRequest
 * @return ConvertInstanceResponse
 */
async function convertInstance(request: ConvertInstanceRequest): ConvertInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return convertInstanceWithOptions(request, runtime);
}

model CreateAccountRequest {
  accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
  accountPassword?: string(name='AccountPassword', description='This parameter is required.', example='**********'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}

model CreateAccountResponseBody = {
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}

model CreateAccountResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateAccountResponseBody(name='body'),
}

/**
 * @summary 新建账户
 *
 * @param request CreateAccountRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateAccountResponse
 */
async function createAccountWithOptions(request: CreateAccountRequest, runtime: Util.RuntimeOptions): CreateAccountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.accountPassword)) {
    query['AccountPassword'] = request.accountPassword;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateAccount',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 新建账户
 *
 * @param request CreateAccountRequest
 * @return CreateAccountResponse
 */
async function createAccount(request: CreateAccountRequest): CreateAccountResponse {
  var runtime = new Util.RuntimeOptions{};
  return createAccountWithOptions(request, runtime);
}

model CreateBackupPlanRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-wz94lbcqc****4x93'),
}

model CreateBackupPlanResponseBody = {
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}

model CreateBackupPlanResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateBackupPlanResponseBody(name='body'),
}

/**
 * @param request CreateBackupPlanRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateBackupPlanResponse
 */
async function createBackupPlanWithOptions(request: CreateBackupPlanRequest, runtime: Util.RuntimeOptions): CreateBackupPlanResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateBackupPlan',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateBackupPlanRequest
 * @return CreateBackupPlanResponse
 */
async function createBackupPlan(request: CreateBackupPlanRequest): CreateBackupPlanResponse {
  var runtime = new Util.RuntimeOptions{};
  return createBackupPlanWithOptions(request, runtime);
}

model CreateClusterRequest {
  autoRenewPeriod?: int32(name='AutoRenewPeriod', example='2'),
  clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
  clusterName?: string(name='ClusterName', example='hbase_test'),
  coldStorageSize?: int32(name='ColdStorageSize', example='1024'),
  coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
  diskSize?: int32(name='DiskSize', example='400'),
  diskType?: string(name='DiskType', example='cloud_ssd'),
  encryptionKey?: string(name='EncryptionKey', example='0d2470df-da7b-4786-b981-9a164dae****'),
  engine?: string(name='Engine', description='This parameter is required.', example='hbase'),
  engineVersion?: string(name='EngineVersion', description='This parameter is required.', example='2.0'),
  masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.medium'),
  nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='2'),
  payType?: string(name='PayType', description='This parameter is required.', example='Prepaid'),
  period?: int32(name='Period', example='6'),
  periodUnit?: string(name='PeriodUnit', example='month'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-j4d53glb3****'),
  securityIPList?: string(name='SecurityIPList', example='116.62.XX.XX/24'),
  vSwitchId?: string(name='VSwitchId', example='vsw-bp191otqj1ssyl****'),
  vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eog****'),
  zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
}

model CreateClusterResponseBody = {
  clusterId?: string(name='ClusterId', example='hb-bp1hy2sjf8gd****'),
  orderId?: string(name='OrderId', example='23232069786****'),
  requestId?: string(name='RequestId', example='3E19E345-101D-4014-946C-A205'),
}

model CreateClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateClusterResponseBody(name='body'),
}

/**
 * @param request CreateClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateClusterResponse
 */
async function createClusterWithOptions(request: CreateClusterRequest, runtime: Util.RuntimeOptions): CreateClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.autoRenewPeriod)) {
    query['AutoRenewPeriod'] = request.autoRenewPeriod;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterName)) {
    query['ClusterName'] = request.clusterName;
  }
  if (!Util.isUnset(request.coldStorageSize)) {
    query['ColdStorageSize'] = request.coldStorageSize;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.diskSize)) {
    query['DiskSize'] = request.diskSize;
  }
  if (!Util.isUnset(request.diskType)) {
    query['DiskType'] = request.diskType;
  }
  if (!Util.isUnset(request.encryptionKey)) {
    query['EncryptionKey'] = request.encryptionKey;
  }
  if (!Util.isUnset(request.engine)) {
    query['Engine'] = request.engine;
  }
  if (!Util.isUnset(request.engineVersion)) {
    query['EngineVersion'] = request.engineVersion;
  }
  if (!Util.isUnset(request.masterInstanceType)) {
    query['MasterInstanceType'] = request.masterInstanceType;
  }
  if (!Util.isUnset(request.nodeCount)) {
    query['NodeCount'] = request.nodeCount;
  }
  if (!Util.isUnset(request.payType)) {
    query['PayType'] = request.payType;
  }
  if (!Util.isUnset(request.period)) {
    query['Period'] = request.period;
  }
  if (!Util.isUnset(request.periodUnit)) {
    query['PeriodUnit'] = request.periodUnit;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceGroupId)) {
    query['ResourceGroupId'] = request.resourceGroupId;
  }
  if (!Util.isUnset(request.securityIPList)) {
    query['SecurityIPList'] = request.securityIPList;
  }
  if (!Util.isUnset(request.vSwitchId)) {
    query['VSwitchId'] = request.vSwitchId;
  }
  if (!Util.isUnset(request.vpcId)) {
    query['VpcId'] = request.vpcId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateClusterRequest
 * @return CreateClusterResponse
 */
async function createCluster(request: CreateClusterRequest): CreateClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return createClusterWithOptions(request, runtime);
}

model CreateGlobalResourceRequest {
  clientToken?: string(name='ClientToken', example='xxxxx-xxxxx-xxxxx'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  regionId?: string(name='RegionId'),
  resourceName?: string(name='ResourceName', description='This parameter is required.', example='PubPhoenixSLBQueryServerVip'),
  resourceType?: string(name='ResourceType', description='This parameter is required.', example='GLOBAL_VIP'),
}

model CreateGlobalResourceResponseBody = {
  requestId?: string(name='RequestId', example='1AB9ABDF-7E1E-44AD-8610-70A005115DD1'),
}

model CreateGlobalResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateGlobalResourceResponseBody(name='body'),
}

/**
 * @param request CreateGlobalResourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateGlobalResourceResponse
 */
async function createGlobalResourceWithOptions(request: CreateGlobalResourceRequest, runtime: Util.RuntimeOptions): CreateGlobalResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceName)) {
    query['ResourceName'] = request.resourceName;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateGlobalResource',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateGlobalResourceRequest
 * @return CreateGlobalResourceResponse
 */
async function createGlobalResource(request: CreateGlobalResourceRequest): CreateGlobalResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return createGlobalResourceWithOptions(request, runtime);
}

model CreateHBaseSlbServerRequest {
  clientToken?: string(name='ClientToken', example='xxxxx-xxxxx-xxxxx'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  slbServer?: string(name='SlbServer', description='This parameter is required.', example='thrift'),
}

model CreateHBaseSlbServerResponseBody = {
  requestId?: string(name='RequestId', example='61FC5B21-87B0-41BC-9686-9DA395EB40B6'),
}

model CreateHBaseSlbServerResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateHBaseSlbServerResponseBody(name='body'),
}

/**
 * @param request CreateHBaseSlbServerRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateHBaseSlbServerResponse
 */
async function createHBaseSlbServerWithOptions(request: CreateHBaseSlbServerRequest, runtime: Util.RuntimeOptions): CreateHBaseSlbServerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.slbServer)) {
    query['SlbServer'] = request.slbServer;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateHBaseSlbServer',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateHBaseSlbServerRequest
 * @return CreateHBaseSlbServerResponse
 */
async function createHBaseSlbServer(request: CreateHBaseSlbServerRequest): CreateHBaseSlbServerResponse {
  var runtime = new Util.RuntimeOptions{};
  return createHBaseSlbServerWithOptions(request, runtime);
}

model CreateHbaseHaSlbRequest {
  bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23****'),
  clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
  haId?: string(name='HaId', description='This parameter is required.', example='ha-v21tmnxjwh2yu****'),
  haTypes?: string(name='HaTypes', description='This parameter is required.', example='thrift'),
  hbaseType?: string(name='HbaseType', description='This parameter is required.', example='Active'),
}

model CreateHbaseHaSlbResponseBody = {
  requestId?: string(name='RequestId', example='C9D568D9-A59C-4AF2-8FBB-F086A841D58E'),
}

model CreateHbaseHaSlbResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateHbaseHaSlbResponseBody(name='body'),
}

/**
 * @param request CreateHbaseHaSlbRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateHbaseHaSlbResponse
 */
async function createHbaseHaSlbWithOptions(request: CreateHbaseHaSlbRequest, runtime: Util.RuntimeOptions): CreateHbaseHaSlbResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bdsId)) {
    query['BdsId'] = request.bdsId;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.haId)) {
    query['HaId'] = request.haId;
  }
  if (!Util.isUnset(request.haTypes)) {
    query['HaTypes'] = request.haTypes;
  }
  if (!Util.isUnset(request.hbaseType)) {
    query['HbaseType'] = request.hbaseType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateHbaseHaSlb',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateHbaseHaSlbRequest
 * @return CreateHbaseHaSlbResponse
 */
async function createHbaseHaSlb(request: CreateHbaseHaSlbRequest): CreateHbaseHaSlbResponse {
  var runtime = new Util.RuntimeOptions{};
  return createHbaseHaSlbWithOptions(request, runtime);
}

model CreateMultiZoneClusterRequest {
  arbiterVSwitchId?: string(name='ArbiterVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxb*****'),
  arbiterZoneId?: string(name='ArbiterZoneId', description='This parameter is required.', example='cn-hangzhou-b'),
  archVersion?: string(name='ArchVersion', description='This parameter is required.', example='2.0'),
  autoRenewPeriod?: int32(name='AutoRenewPeriod', example='0'),
  clientToken?: string(name='ClientToken', example='dfh3sf5gslfksfk****'),
  clusterName?: string(name='ClusterName', example='hbaseue_test'),
  coreDiskSize?: int32(name='CoreDiskSize', description='This parameter is required.', example='400'),
  coreDiskType?: string(name='CoreDiskType', description='This parameter is required.', example='cloud_ssd'),
  coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
  coreNodeCount?: int32(name='CoreNodeCount', description='This parameter is required.', example='4'),
  engine?: string(name='Engine', description='This parameter is required.', example='hbaseue'),
  engineVersion?: string(name='EngineVersion', description='This parameter is required.', example='2.0'),
  logDiskSize?: int32(name='LogDiskSize', description='This parameter is required.', example='400'),
  logDiskType?: string(name='LogDiskType', description='This parameter is required.', example='cloud_ssd'),
  logInstanceType?: string(name='LogInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
  logNodeCount?: int32(name='LogNodeCount', description='This parameter is required.', example='4'),
  masterInstanceType?: string(name='MasterInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
  multiZoneCombination?: string(name='MultiZoneCombination', description='This parameter is required.', example='cn-hangzhou-bef-aliyun-com'),
  payType?: string(name='PayType', description='This parameter is required.', example='Postpaid'),
  period?: int32(name='Period', example='1'),
  periodUnit?: string(name='PeriodUnit', example='month'),
  primaryVSwitchId?: string(name='PrimaryVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxe****'),
  primaryZoneId?: string(name='PrimaryZoneId', description='This parameter is required.', example='cn-hangzhou-e'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-gg3f4f5d5g5w****'),
  securityIPList?: string(name='SecurityIPList', example='127.0.0.1'),
  standbyVSwitchId?: string(name='StandbyVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxf****'),
  standbyZoneId?: string(name='StandbyZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
  vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-bp120k6ixs4eog****'),
}

model CreateMultiZoneClusterResponseBody = {
  clusterId?: string(name='ClusterId', example='ld-t4nn71xa0yn56****'),
  orderId?: string(name='OrderId', example='23232453****'),
  requestId?: string(name='RequestId', example='7F68E8F5-0377-4CF8-8B1D-FFFD6F5804D5'),
}

model CreateMultiZoneClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateMultiZoneClusterResponseBody(name='body'),
}

/**
 * @param request CreateMultiZoneClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateMultiZoneClusterResponse
 */
async function createMultiZoneClusterWithOptions(request: CreateMultiZoneClusterRequest, runtime: Util.RuntimeOptions): CreateMultiZoneClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.arbiterVSwitchId)) {
    query['ArbiterVSwitchId'] = request.arbiterVSwitchId;
  }
  if (!Util.isUnset(request.arbiterZoneId)) {
    query['ArbiterZoneId'] = request.arbiterZoneId;
  }
  if (!Util.isUnset(request.archVersion)) {
    query['ArchVersion'] = request.archVersion;
  }
  if (!Util.isUnset(request.autoRenewPeriod)) {
    query['AutoRenewPeriod'] = request.autoRenewPeriod;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterName)) {
    query['ClusterName'] = request.clusterName;
  }
  if (!Util.isUnset(request.coreDiskSize)) {
    query['CoreDiskSize'] = request.coreDiskSize;
  }
  if (!Util.isUnset(request.coreDiskType)) {
    query['CoreDiskType'] = request.coreDiskType;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.coreNodeCount)) {
    query['CoreNodeCount'] = request.coreNodeCount;
  }
  if (!Util.isUnset(request.engine)) {
    query['Engine'] = request.engine;
  }
  if (!Util.isUnset(request.engineVersion)) {
    query['EngineVersion'] = request.engineVersion;
  }
  if (!Util.isUnset(request.logDiskSize)) {
    query['LogDiskSize'] = request.logDiskSize;
  }
  if (!Util.isUnset(request.logDiskType)) {
    query['LogDiskType'] = request.logDiskType;
  }
  if (!Util.isUnset(request.logInstanceType)) {
    query['LogInstanceType'] = request.logInstanceType;
  }
  if (!Util.isUnset(request.logNodeCount)) {
    query['LogNodeCount'] = request.logNodeCount;
  }
  if (!Util.isUnset(request.masterInstanceType)) {
    query['MasterInstanceType'] = request.masterInstanceType;
  }
  if (!Util.isUnset(request.multiZoneCombination)) {
    query['MultiZoneCombination'] = request.multiZoneCombination;
  }
  if (!Util.isUnset(request.payType)) {
    query['PayType'] = request.payType;
  }
  if (!Util.isUnset(request.period)) {
    query['Period'] = request.period;
  }
  if (!Util.isUnset(request.periodUnit)) {
    query['PeriodUnit'] = request.periodUnit;
  }
  if (!Util.isUnset(request.primaryVSwitchId)) {
    query['PrimaryVSwitchId'] = request.primaryVSwitchId;
  }
  if (!Util.isUnset(request.primaryZoneId)) {
    query['PrimaryZoneId'] = request.primaryZoneId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceGroupId)) {
    query['ResourceGroupId'] = request.resourceGroupId;
  }
  if (!Util.isUnset(request.securityIPList)) {
    query['SecurityIPList'] = request.securityIPList;
  }
  if (!Util.isUnset(request.standbyVSwitchId)) {
    query['StandbyVSwitchId'] = request.standbyVSwitchId;
  }
  if (!Util.isUnset(request.standbyZoneId)) {
    query['StandbyZoneId'] = request.standbyZoneId;
  }
  if (!Util.isUnset(request.vpcId)) {
    query['VpcId'] = request.vpcId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateMultiZoneCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateMultiZoneClusterRequest
 * @return CreateMultiZoneClusterResponse
 */
async function createMultiZoneCluster(request: CreateMultiZoneClusterRequest): CreateMultiZoneClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMultiZoneClusterWithOptions(request, runtime);
}

model CreateRestorePlanRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  restoreAllTable?: boolean(name='RestoreAllTable', description='This parameter is required.', example='false'),
  restoreByCopy?: boolean(name='RestoreByCopy', description='This parameter is required.', example='true'),
  restoreToDate?: string(name='RestoreToDate', description='This parameter is required.', example='2020-11-05T05:49:42Z'),
  tables?: string(name='Tables', example='test_ns:test_table/test_ns:test_table2'),
  targetClusterId?: string(name='TargetClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
}

model CreateRestorePlanResponseBody = {
  requestId?: string(name='RequestId', example='A0598673-EB6E-4F6D-9961-E0F2012090C0'),
}

model CreateRestorePlanResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateRestorePlanResponseBody(name='body'),
}

/**
 * @param request CreateRestorePlanRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateRestorePlanResponse
 */
async function createRestorePlanWithOptions(request: CreateRestorePlanRequest, runtime: Util.RuntimeOptions): CreateRestorePlanResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.restoreAllTable)) {
    query['RestoreAllTable'] = request.restoreAllTable;
  }
  if (!Util.isUnset(request.restoreByCopy)) {
    query['RestoreByCopy'] = request.restoreByCopy;
  }
  if (!Util.isUnset(request.restoreToDate)) {
    query['RestoreToDate'] = request.restoreToDate;
  }
  if (!Util.isUnset(request.tables)) {
    query['Tables'] = request.tables;
  }
  if (!Util.isUnset(request.targetClusterId)) {
    query['TargetClusterId'] = request.targetClusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateRestorePlan',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateRestorePlanRequest
 * @return CreateRestorePlanResponse
 */
async function createRestorePlan(request: CreateRestorePlanRequest): CreateRestorePlanResponse {
  var runtime = new Util.RuntimeOptions{};
  return createRestorePlanWithOptions(request, runtime);
}

model CreateServerlessClusterRequest {
  autoRenewPeriod?: int32(name='AutoRenewPeriod', example='2'),
  clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
  clientType?: string(name='ClientType', example='xx'),
  clusterName?: string(name='ClusterName', example='serverless-name'),
  diskType?: string(name='DiskType', example='cloud_ssd'),
  engine?: string(name='Engine', example='serverlesshbase'),
  engineVersion?: string(name='EngineVersion', example='2.0'),
  payType?: string(name='PayType', description='This parameter is required.', example='Prepaid'),
  period?: int32(name='Period', example='6'),
  periodUnit?: string(name='PeriodUnit', example='month'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-j4d53glb3****'),
  serverlessCapability?: int32(name='ServerlessCapability', example='1000'),
  serverlessSpec?: string(name='ServerlessSpec', example='serverless.small'),
  serverlessStorage?: int32(name='ServerlessStorage', example='100'),
  vSwitchId?: string(name='VSwitchId', example='vsw-bp191ipotqj1ssyl*****'),
  vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eog****'),
  zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
}

model CreateServerlessClusterResponseBody = {
  clusterId?: string(name='ClusterId', example='sh-bp1a969y7681****'),
  orderId?: string(name='OrderId', example='23232453233*****'),
  passWord?: string(name='PassWord', example='*********'),
  requestId?: string(name='RequestId', example='3E19E345-101D-4014-946C-************'),
}

model CreateServerlessClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateServerlessClusterResponseBody(name='body'),
}

/**
 * @param request CreateServerlessClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateServerlessClusterResponse
 */
async function createServerlessClusterWithOptions(request: CreateServerlessClusterRequest, runtime: Util.RuntimeOptions): CreateServerlessClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.autoRenewPeriod)) {
    query['AutoRenewPeriod'] = request.autoRenewPeriod;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clientType)) {
    query['ClientType'] = request.clientType;
  }
  if (!Util.isUnset(request.clusterName)) {
    query['ClusterName'] = request.clusterName;
  }
  if (!Util.isUnset(request.diskType)) {
    query['DiskType'] = request.diskType;
  }
  if (!Util.isUnset(request.engine)) {
    query['Engine'] = request.engine;
  }
  if (!Util.isUnset(request.engineVersion)) {
    query['EngineVersion'] = request.engineVersion;
  }
  if (!Util.isUnset(request.payType)) {
    query['PayType'] = request.payType;
  }
  if (!Util.isUnset(request.period)) {
    query['Period'] = request.period;
  }
  if (!Util.isUnset(request.periodUnit)) {
    query['PeriodUnit'] = request.periodUnit;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceGroupId)) {
    query['ResourceGroupId'] = request.resourceGroupId;
  }
  if (!Util.isUnset(request.serverlessCapability)) {
    query['ServerlessCapability'] = request.serverlessCapability;
  }
  if (!Util.isUnset(request.serverlessSpec)) {
    query['ServerlessSpec'] = request.serverlessSpec;
  }
  if (!Util.isUnset(request.serverlessStorage)) {
    query['ServerlessStorage'] = request.serverlessStorage;
  }
  if (!Util.isUnset(request.vSwitchId)) {
    query['VSwitchId'] = request.vSwitchId;
  }
  if (!Util.isUnset(request.vpcId)) {
    query['VpcId'] = request.vpcId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateServerlessCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request CreateServerlessClusterRequest
 * @return CreateServerlessClusterResponse
 */
async function createServerlessCluster(request: CreateServerlessClusterRequest): CreateServerlessClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return createServerlessClusterWithOptions(request, runtime);
}

model DeleteAccountRequest {
  accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}

model DeleteAccountResponseBody = {
  requestId?: string(name='RequestId', example='729CB2A7-3065-53A9-B27C-7033CA4881D9'),
}

model DeleteAccountResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAccountResponseBody(name='body'),
}

/**
 * @summary 删除账户
 *
 * @param request DeleteAccountRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteAccountResponse
 */
async function deleteAccountWithOptions(request: DeleteAccountRequest, runtime: Util.RuntimeOptions): DeleteAccountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAccount',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 删除账户
 *
 * @param request DeleteAccountRequest
 * @return DeleteAccountResponse
 */
async function deleteAccount(request: DeleteAccountRequest): DeleteAccountResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAccountWithOptions(request, runtime);
}

model DeleteGlobalResourceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
  regionId?: string(name='RegionId'),
  resourceName?: string(name='ResourceName', description='This parameter is required.', example='PubPhoenixSLBQueryServerVip'),
  resourceType?: string(name='ResourceType', description='This parameter is required.', example='GLOBAL_VIP'),
}

model DeleteGlobalResourceResponseBody = {
  requestId?: string(name='RequestId', example='BD0B0B9A-79E8-4FDD-9C51-93443490B784'),
}

model DeleteGlobalResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteGlobalResourceResponseBody(name='body'),
}

/**
 * @param request DeleteGlobalResourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteGlobalResourceResponse
 */
async function deleteGlobalResourceWithOptions(request: DeleteGlobalResourceRequest, runtime: Util.RuntimeOptions): DeleteGlobalResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceName)) {
    query['ResourceName'] = request.resourceName;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteGlobalResource',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteGlobalResourceRequest
 * @return DeleteGlobalResourceResponse
 */
async function deleteGlobalResource(request: DeleteGlobalResourceRequest): DeleteGlobalResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteGlobalResourceWithOptions(request, runtime);
}

model DeleteHBaseHaDBRequest {
  bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-bp14112fd7g52s1****'),
  haId?: string(name='HaId', description='This parameter is required.', example='ha-sw2o0l01s4r76****'),
}

model DeleteHBaseHaDBResponseBody = {
  requestId?: string(name='RequestId', example='B409CF51-E01F-4551-BE40-123678FA9026'),
}

model DeleteHBaseHaDBResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteHBaseHaDBResponseBody(name='body'),
}

/**
 * @param request DeleteHBaseHaDBRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteHBaseHaDBResponse
 */
async function deleteHBaseHaDBWithOptions(request: DeleteHBaseHaDBRequest, runtime: Util.RuntimeOptions): DeleteHBaseHaDBResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bdsId)) {
    query['BdsId'] = request.bdsId;
  }
  if (!Util.isUnset(request.haId)) {
    query['HaId'] = request.haId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteHBaseHaDB',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteHBaseHaDBRequest
 * @return DeleteHBaseHaDBResponse
 */
async function deleteHBaseHaDB(request: DeleteHBaseHaDBRequest): DeleteHBaseHaDBResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteHBaseHaDBWithOptions(request, runtime);
}

model DeleteHBaseSlbServerRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  slbServer?: string(name='SlbServer', description='This parameter is required.', example='thrift'),
}

model DeleteHBaseSlbServerResponseBody = {
  requestId?: string(name='RequestId', example='7242130A-82CF-49BF-AB32-30DCB819EBA6'),
}

model DeleteHBaseSlbServerResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteHBaseSlbServerResponseBody(name='body'),
}

/**
 * @param request DeleteHBaseSlbServerRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteHBaseSlbServerResponse
 */
async function deleteHBaseSlbServerWithOptions(request: DeleteHBaseSlbServerRequest, runtime: Util.RuntimeOptions): DeleteHBaseSlbServerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.slbServer)) {
    query['SlbServer'] = request.slbServer;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteHBaseSlbServer',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteHBaseSlbServerRequest
 * @return DeleteHBaseSlbServerResponse
 */
async function deleteHBaseSlbServer(request: DeleteHBaseSlbServerRequest): DeleteHBaseSlbServerResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteHBaseSlbServerWithOptions(request, runtime);
}

model DeleteHbaseHaSlbRequest {
  bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23ia4k'),
  haId?: string(name='HaId', description='This parameter is required.', example='ha-v21tmnxjwh2yuy1il'),
  haTypes?: string(name='HaTypes', description='This parameter is required.', example='thrift'),
}

model DeleteHbaseHaSlbResponseBody = {
  requestId?: string(name='RequestId', example='C9D568D9-A59C-4AF2-8FBB-F086A841D58E'),
}

model DeleteHbaseHaSlbResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteHbaseHaSlbResponseBody(name='body'),
}

/**
 * @param request DeleteHbaseHaSlbRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteHbaseHaSlbResponse
 */
async function deleteHbaseHaSlbWithOptions(request: DeleteHbaseHaSlbRequest, runtime: Util.RuntimeOptions): DeleteHbaseHaSlbResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bdsId)) {
    query['BdsId'] = request.bdsId;
  }
  if (!Util.isUnset(request.haId)) {
    query['HaId'] = request.haId;
  }
  if (!Util.isUnset(request.haTypes)) {
    query['HaTypes'] = request.haTypes;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteHbaseHaSlb',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteHbaseHaSlbRequest
 * @return DeleteHbaseHaSlbResponse
 */
async function deleteHbaseHaSlb(request: DeleteHbaseHaSlbRequest): DeleteHbaseHaSlbResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteHbaseHaSlbWithOptions(request, runtime);
}

model DeleteInstanceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
  immediateDeleteFlag?: boolean(name='ImmediateDeleteFlag', example='false'),
}

model DeleteInstanceResponseBody = {
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}

model DeleteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteInstanceResponseBody(name='body'),
}

/**
 * @param request DeleteInstanceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteInstanceResponse
 */
async function deleteInstanceWithOptions(request: DeleteInstanceRequest, runtime: Util.RuntimeOptions): DeleteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.immediateDeleteFlag)) {
    query['ImmediateDeleteFlag'] = request.immediateDeleteFlag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteInstance',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteInstanceRequest
 * @return DeleteInstanceResponse
 */
async function deleteInstance(request: DeleteInstanceRequest): DeleteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteInstanceWithOptions(request, runtime);
}

model DeleteMultiZoneClusterRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='d-t4nn71xa0yn56****'),
  immediateDeleteFlag?: boolean(name='ImmediateDeleteFlag', example='false'),
}

model DeleteMultiZoneClusterResponseBody = {
  requestId?: string(name='RequestId', example='169A3910-A39E-4BC2-AA9F-E7AD8D473527'),
}

model DeleteMultiZoneClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteMultiZoneClusterResponseBody(name='body'),
}

/**
 * @param request DeleteMultiZoneClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteMultiZoneClusterResponse
 */
async function deleteMultiZoneClusterWithOptions(request: DeleteMultiZoneClusterRequest, runtime: Util.RuntimeOptions): DeleteMultiZoneClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.immediateDeleteFlag)) {
    query['ImmediateDeleteFlag'] = request.immediateDeleteFlag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteMultiZoneCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteMultiZoneClusterRequest
 * @return DeleteMultiZoneClusterResponse
 */
async function deleteMultiZoneCluster(request: DeleteMultiZoneClusterRequest): DeleteMultiZoneClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteMultiZoneClusterWithOptions(request, runtime);
}

model DeleteServerlessClusterRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='sh-bp1pj13wh9****'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-shenzhen'),
  zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-shenzhen-e'),
}

model DeleteServerlessClusterResponseBody = {
  requestId?: string(name='RequestId', example='46950E74-59C4-4E3E-9B38-A33B*********'),
}

model DeleteServerlessClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteServerlessClusterResponseBody(name='body'),
}

/**
 * @param request DeleteServerlessClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteServerlessClusterResponse
 */
async function deleteServerlessClusterWithOptions(request: DeleteServerlessClusterRequest, runtime: Util.RuntimeOptions): DeleteServerlessClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteServerlessCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteServerlessClusterRequest
 * @return DeleteServerlessClusterResponse
 */
async function deleteServerlessCluster(request: DeleteServerlessClusterRequest): DeleteServerlessClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteServerlessClusterWithOptions(request, runtime);
}

model DeleteUserHdfsInfoRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
  nameService?: string(name='NameService', description='This parameter is required.', example='hdfs_test'),
}

model DeleteUserHdfsInfoResponseBody = {
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}

model DeleteUserHdfsInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteUserHdfsInfoResponseBody(name='body'),
}

/**
 * @param request DeleteUserHdfsInfoRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DeleteUserHdfsInfoResponse
 */
async function deleteUserHdfsInfoWithOptions(request: DeleteUserHdfsInfoRequest, runtime: Util.RuntimeOptions): DeleteUserHdfsInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.nameService)) {
    query['NameService'] = request.nameService;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteUserHdfsInfo',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DeleteUserHdfsInfoRequest
 * @return DeleteUserHdfsInfoResponse
 */
async function deleteUserHdfsInfo(request: DeleteUserHdfsInfoRequest): DeleteUserHdfsInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteUserHdfsInfoWithOptions(request, runtime);
}

model DescribeAccountsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1uoihlf82e8****'),
}

model DescribeAccountsResponseBody = {
  accounts?: {
    account?: [ string ](name='account')
  }(name='Accounts'),
  requestId?: string(name='RequestId', example='F744E939-D08D-5623-82C8-9D1F9F7685D1'),
}

model DescribeAccountsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAccountsResponseBody(name='body'),
}

/**
 * @summary 查询账户列表
 *
 * @param request DescribeAccountsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeAccountsResponse
 */
async function describeAccountsWithOptions(request: DescribeAccountsRequest, runtime: Util.RuntimeOptions): DescribeAccountsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAccounts',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 查询账户列表
 *
 * @param request DescribeAccountsRequest
 * @return DescribeAccountsResponse
 */
async function describeAccounts(request: DescribeAccountsRequest): DescribeAccountsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAccountsWithOptions(request, runtime);
}

model DescribeActiveOperationTaskTypeRequest {
  isHistory?: int32(name='IsHistory', example='0'),
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  securityToken?: string(name='SecurityToken'),
}

model DescribeActiveOperationTaskTypeResponseBody = {
  requestId?: string(name='RequestId', example='EC7E27FC-58F8-4722-89CF-D1B6B0971956'),
  typeList?: [ 
    {
      count?: int32(name='Count', example='1'),
      taskType?: string(name='TaskType', example='rds_apsaradb_upgrade'),
      taskTypeInfoEn?: string(name='TaskTypeInfoEn', example='rds_apsaradb_upgrade'),
      taskTypeInfoZh?: string(name='TaskTypeInfoZh'),
    }
  ](name='TypeList'),
}

model DescribeActiveOperationTaskTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeActiveOperationTaskTypeResponseBody(name='body'),
}

/**
 * @param request DescribeActiveOperationTaskTypeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeActiveOperationTaskTypeResponse
 */
async function describeActiveOperationTaskTypeWithOptions(request: DescribeActiveOperationTaskTypeRequest, runtime: Util.RuntimeOptions): DescribeActiveOperationTaskTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.isHistory)) {
    query['IsHistory'] = request.isHistory;
  }
  if (!Util.isUnset(request.ownerAccount)) {
    query['OwnerAccount'] = request.ownerAccount;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.securityToken)) {
    query['SecurityToken'] = request.securityToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeActiveOperationTaskType',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeActiveOperationTaskTypeRequest
 * @return DescribeActiveOperationTaskTypeResponse
 */
async function describeActiveOperationTaskType(request: DescribeActiveOperationTaskTypeRequest): DescribeActiveOperationTaskTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeActiveOperationTaskTypeWithOptions(request, runtime);
}

model DescribeActiveOperationTasksRequest {
  allowCancel?: int32(name='AllowCancel', example='1'),
  allowChange?: int32(name='AllowChange', example='1'),
  changeLevel?: string(name='ChangeLevel', example='S1'),
  dbType?: string(name='DbType', example='hbaseue'),
  insName?: string(name='InsName', example='ld-bp150tns0sjxs****'),
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='30'),
  productId?: string(name='ProductId', example='hbase'),
  region?: string(name='Region', example='cn-hangzhou'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  securityToken?: string(name='SecurityToken'),
  status?: int32(name='Status', example='5'),
  taskType?: string(name='TaskType', example='rds_apsaradb_upgrade'),
}

model DescribeActiveOperationTasksResponseBody = {
  items?: [ 
    {
      allowCancel?: string(name='AllowCancel', example='1'),
      allowChange?: string(name='AllowChange', example='1'),
      changeLevel?: string(name='ChangeLevel', example='all'),
      changeLevelEn?: string(name='ChangeLevelEn', example='Risk repairment'),
      changeLevelZh?: string(name='ChangeLevelZh'),
      createdTime?: string(name='CreatedTime', example='2022-02-15 23:59:59'),
      currentAVZ?: string(name='CurrentAVZ', example='cn-shanghai-et-a'),
      dbType?: string(name='DbType', example='hbaseue'),
      dbVersion?: string(name='DbVersion', example='2.0'),
      deadline?: string(name='Deadline', example='2022-02-19 23:59:59'),
      id?: int32(name='Id', example='111111'),
      impactEn?: string(name='ImpactEn', example='Transient instance disconnection'),
      impactZh?: string(name='ImpactZh'),
      insComment?: string(name='InsComment', example='--'),
      insName?: string(name='InsName', example='ld-bp150tns0sjxs****'),
      modifiedTime?: string(name='ModifiedTime', example='2022-02-19 14:00:00'),
      prepareInterval?: string(name='PrepareInterval', example='14:00:00'),
      region?: string(name='Region', example='cn-hanghzou'),
      resultInfo?: string(name='ResultInfo', example='--'),
      startTime?: string(name='StartTime', example='2022-02-19 10:00:00'),
      status?: int32(name='Status', example='5'),
      subInsNames?: [ string ](name='SubInsNames'),
      switchTime?: string(name='SwitchTime', example='2022-02-19 14:00:00'),
      taskType?: string(name='TaskType', example='rds_apsaradb_upgrade'),
      taskTypeEn?: string(name='TaskTypeEn', example='rds_apsaradb_upgrade'),
      taskTypeZh?: string(name='TaskTypeZh'),
    }
  ](name='Items'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='30'),
  requestId?: string(name='RequestId', example='C634E813-42FA-53D2-A7EB-B881C4B264CC'),
  totalRecordCount?: int32(name='TotalRecordCount', example='1'),
}

model DescribeActiveOperationTasksResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeActiveOperationTasksResponseBody(name='body'),
}

/**
 * @param request DescribeActiveOperationTasksRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeActiveOperationTasksResponse
 */
async function describeActiveOperationTasksWithOptions(request: DescribeActiveOperationTasksRequest, runtime: Util.RuntimeOptions): DescribeActiveOperationTasksResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.allowCancel)) {
    query['AllowCancel'] = request.allowCancel;
  }
  if (!Util.isUnset(request.allowChange)) {
    query['AllowChange'] = request.allowChange;
  }
  if (!Util.isUnset(request.changeLevel)) {
    query['ChangeLevel'] = request.changeLevel;
  }
  if (!Util.isUnset(request.dbType)) {
    query['DbType'] = request.dbType;
  }
  if (!Util.isUnset(request.insName)) {
    query['InsName'] = request.insName;
  }
  if (!Util.isUnset(request.ownerAccount)) {
    query['OwnerAccount'] = request.ownerAccount;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.productId)) {
    query['ProductId'] = request.productId;
  }
  if (!Util.isUnset(request.region)) {
    query['Region'] = request.region;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.securityToken)) {
    query['SecurityToken'] = request.securityToken;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.taskType)) {
    query['TaskType'] = request.taskType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeActiveOperationTasks',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeActiveOperationTasksRequest
 * @return DescribeActiveOperationTasksResponse
 */
async function describeActiveOperationTasks(request: DescribeActiveOperationTasksRequest): DescribeActiveOperationTasksResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeActiveOperationTasksWithOptions(request, runtime);
}

model DescribeAvailableResourceRequest {
  chargeType?: string(name='ChargeType', description='This parameter is required.', example='Prepaid'),
  coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
  diskType?: string(name='DiskType', example='cloud_ssd'),
  engine?: string(name='Engine', example='hbaseue'),
  engineVersion?: string(name='EngineVersion', example='2.0'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  zoneId?: string(name='ZoneId', example='cn-hangzhou-h'),
}

model DescribeAvailableResourceResponseBody = {
  availableZones?: {
    availableZone?: [ 
    {
      masterResources?: {
        masterResource?: [ 
        {
          instanceType?: string(name='InstanceType', example='hbase.sn1.medium'),
          instanceTypeDetail?: {
            cpu?: int32(name='Cpu', example='4'),
            mem?: int32(name='Mem', example='8'),
          }(name='InstanceTypeDetail'),
        }
      ](name='MasterResource')
      }(name='MasterResources'),
      regionId?: string(name='RegionId', example='cn-shenzhen'),
      supportedEngines?: {
        supportedEngine?: [ 
        {
          engine?: string(name='Engine', example='hbase'),
          supportedEngineVersions?: {
            supportedEngineVersion?: [ 
            {
              supportedCategories?: {
                supportedCategories?: [ 
                {
                  category?: string(name='Category', example='cluster'),
                  supportedStorageTypes?: {
                    supportedStorageType?: [ 
                    {
                      coreResources?: {
                        coreResource?: [ 
                        {
                          DBInstanceStorageRange?: {
                            maxSize?: int32(name='MaxSize', example='8000'),
                            minSize?: int32(name='MinSize', example='400'),
                            stepSize?: int32(name='StepSize', example='40'),
                          }(name='DBInstanceStorageRange'),
                          instanceType?: string(name='InstanceType', example='hbase.sn1.large'),
                          instanceTypeDetail?: {
                            cpu?: int32(name='Cpu', example='4'),
                            mem?: int32(name='Mem', example='8'),
                          }(name='InstanceTypeDetail'),
                          maxCoreCount?: int32(name='MaxCoreCount', example='16'),
                        }
                      ](name='CoreResource')
                      }(name='CoreResources'),
                      storageType?: string(name='StorageType', example='cloud_ssd'),
                    }
                  ](name='SupportedStorageType')
                  }(name='SupportedStorageTypes'),
                }
              ](name='SupportedCategories')
              }(name='SupportedCategories'),
              version?: string(name='Version', example='2.0'),
            }
          ](name='SupportedEngineVersion')
          }(name='SupportedEngineVersions'),
        }
      ](name='SupportedEngine')
      }(name='SupportedEngines'),
      zoneId?: string(name='ZoneId', example='cn-shenzhen-e'),
    }
  ](name='AvailableZone')
  }(name='AvailableZones'),
  requestId?: string(name='RequestId', example='EA76F208-E334-592A-A0C6-41E15EC87ED0'),
}

model DescribeAvailableResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAvailableResourceResponseBody(name='body'),
}

/**
 * @param request DescribeAvailableResourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeAvailableResourceResponse
 */
async function describeAvailableResourceWithOptions(request: DescribeAvailableResourceRequest, runtime: Util.RuntimeOptions): DescribeAvailableResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.chargeType)) {
    query['ChargeType'] = request.chargeType;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.diskType)) {
    query['DiskType'] = request.diskType;
  }
  if (!Util.isUnset(request.engine)) {
    query['Engine'] = request.engine;
  }
  if (!Util.isUnset(request.engineVersion)) {
    query['EngineVersion'] = request.engineVersion;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAvailableResource',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeAvailableResourceRequest
 * @return DescribeAvailableResourceResponse
 */
async function describeAvailableResource(request: DescribeAvailableResourceRequest): DescribeAvailableResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAvailableResourceWithOptions(request, runtime);
}

model DescribeBackupPlanConfigRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
}

model DescribeBackupPlanConfigResponseBody = {
  fullBackupCycle?: int32(name='FullBackupCycle', example='7'),
  minHFileBackupCount?: int32(name='MinHFileBackupCount', example='3'),
  nextFullBackupDate?: string(name='NextFullBackupDate', example='2020-11-09T18:00:00Z'),
  requestId?: string(name='RequestId', example='33A23201-6038-4A6A-B76A-61047EA04E6A'),
  tables?: {
    table?: [ string ](name='Table')
  }(name='Tables'),
}

model DescribeBackupPlanConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBackupPlanConfigResponseBody(name='body'),
}

/**
 * @param request DescribeBackupPlanConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeBackupPlanConfigResponse
 */
async function describeBackupPlanConfigWithOptions(request: DescribeBackupPlanConfigRequest, runtime: Util.RuntimeOptions): DescribeBackupPlanConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBackupPlanConfig',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeBackupPlanConfigRequest
 * @return DescribeBackupPlanConfigResponse
 */
async function describeBackupPlanConfig(request: DescribeBackupPlanConfigRequest): DescribeBackupPlanConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBackupPlanConfigWithOptions(request, runtime);
}

model DescribeBackupPolicyRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}

model DescribeBackupPolicyResponseBody = {
  backupRetentionPeriod?: string(name='BackupRetentionPeriod', example='10'),
  preferredBackupEndTimeUTC?: string(name='PreferredBackupEndTimeUTC', example='18:00Z'),
  preferredBackupPeriod?: string(name='PreferredBackupPeriod', example='Friday'),
  preferredBackupStartTimeUTC?: string(name='PreferredBackupStartTimeUTC', example='17:00Z'),
  preferredBackupTime?: string(name='PreferredBackupTime', example='01:00-02:00'),
  requestId?: string(name='RequestId', example='94AC38B6-7C6D-45B2-BC03-B8750071A482'),
}

model DescribeBackupPolicyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBackupPolicyResponseBody(name='body'),
}

/**
 * @param request DescribeBackupPolicyRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeBackupPolicyResponse
 */
async function describeBackupPolicyWithOptions(request: DescribeBackupPolicyRequest, runtime: Util.RuntimeOptions): DescribeBackupPolicyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBackupPolicy',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeBackupPolicyRequest
 * @return DescribeBackupPolicyResponse
 */
async function describeBackupPolicy(request: DescribeBackupPolicyRequest): DescribeBackupPolicyResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBackupPolicyWithOptions(request, runtime);
}

model DescribeBackupStatusRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
}

model DescribeBackupStatusResponseBody = {
  backupStatus?: string(name='BackupStatus', example='opened'),
  bdsClusterId?: string(name='BdsClusterId', example='bds-m5e54q06ceyhxxxx'),
  clusterId?: string(name='ClusterId', example='ld-m5eznlga4k5bcxxxx'),
  requestId?: string(name='RequestId', example='F7E71430-A825-470A-B40B-DF3F3AAC9BEE'),
}

model DescribeBackupStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBackupStatusResponseBody(name='body'),
}

/**
 * @param request DescribeBackupStatusRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeBackupStatusResponse
 */
async function describeBackupStatusWithOptions(request: DescribeBackupStatusRequest, runtime: Util.RuntimeOptions): DescribeBackupStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBackupStatus',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeBackupStatusRequest
 * @return DescribeBackupStatusResponse
 */
async function describeBackupStatus(request: DescribeBackupStatusRequest): DescribeBackupStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBackupStatusWithOptions(request, runtime);
}

model DescribeBackupSummaryRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
}

model DescribeBackupSummaryResponseBody = {
  full?: {
    hasMore?: string(name='HasMore', example='false'),
    nextFullBackupDate?: string(name='NextFullBackupDate', example='2020-11-09T18:00:00Z'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    records?: {
      record?: [ 
      {
        createTime?: string(name='CreateTime', example='2020-11-02T18:00:00Z'),
        dataSize?: string(name='DataSize', example='1.2 kB'),
        finishTime?: string(name='FinishTime', example='2020-11-02T18:02:04Z'),
        process?: string(name='Process', example='1/1'),
        recordId?: string(name='RecordId', example='20201103020000'),
        speed?: string(name='Speed', example='0.00 MB/s'),
        status?: string(name='Status', example='SUCCESS'),
      }
    ](name='Record')
    }(name='Records'),
    total?: int32(name='Total', example='2'),
  }(name='Full'),
  incr?: {
    backupLogSize?: string(name='BackupLogSize', example='266 B'),
    pos?: string(name='Pos', example='2020-11-05T01:20:31Z'),
    queueLogNum?: string(name='QueueLogNum', example='0'),
    runningLogNum?: string(name='RunningLogNum', example='2'),
    speed?: string(name='Speed', example='0.00 MB/s'),
    status?: string(name='Status', example='RUNNING'),
  }(name='Incr'),
  requestId?: string(name='RequestId', example='168793CB-7B31-43E7-ADAB-FE3E8D584D6E'),
}

model DescribeBackupSummaryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBackupSummaryResponseBody(name='body'),
}

/**
 * @param request DescribeBackupSummaryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeBackupSummaryResponse
 */
async function describeBackupSummaryWithOptions(request: DescribeBackupSummaryRequest, runtime: Util.RuntimeOptions): DescribeBackupSummaryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBackupSummary',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeBackupSummaryRequest
 * @return DescribeBackupSummaryResponse
 */
async function describeBackupSummary(request: DescribeBackupSummaryRequest): DescribeBackupSummaryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBackupSummaryWithOptions(request, runtime);
}

model DescribeBackupTablesRequest {
  backupRecordId?: string(name='BackupRecordId', description='This parameter is required.', example='2020110302xxxx'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
}

model DescribeBackupTablesResponseBody = {
  backupRecords?: {
    backupRecord?: [ 
    {
      dataSize?: string(name='DataSize', example='1.2 kB'),
      endTime?: string(name='EndTime', example='2020-11-02T18:00:05Z'),
      message?: string(name='Message', example='null'),
      process?: string(name='Process', example='14/14'),
      speed?: string(name='Speed', example='0.00 MB/s'),
      startTime?: string(name='StartTime', example='2020-11-02T18:00:00Z'),
      state?: string(name='State', example='SUCCEEDED'),
      table?: string(name='Table', example='default:test1'),
    }
  ](name='BackupRecord')
  }(name='BackupRecords'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='01262E9C-B0CC-4663-82FA-D50173649F92'),
  tables?: {
    table?: [ string ](name='Table')
  }(name='Tables'),
  total?: long(name='Total', example='1'),
}

model DescribeBackupTablesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBackupTablesResponseBody(name='body'),
}

/**
 * @param request DescribeBackupTablesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeBackupTablesResponse
 */
async function describeBackupTablesWithOptions(request: DescribeBackupTablesRequest, runtime: Util.RuntimeOptions): DescribeBackupTablesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.backupRecordId)) {
    query['BackupRecordId'] = request.backupRecordId;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBackupTables',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeBackupTablesRequest
 * @return DescribeBackupTablesResponse
 */
async function describeBackupTables(request: DescribeBackupTablesRequest): DescribeBackupTablesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBackupTablesWithOptions(request, runtime);
}

model DescribeBackupsRequest {
  backupId?: string(name='BackupId', example='job-xxxx'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  endTime?: string(name='EndTime', example='2020-12-23 23:59:59'),
  endTimeUTC?: string(name='EndTimeUTC', example='2020-12-23T15:59:59Z'),
  pageNumber?: string(name='PageNumber', example='1'),
  pageSize?: string(name='PageSize', example='10'),
  startTime?: string(name='StartTime', example='2020-12-13 00:00:00'),
  startTimeUTC?: string(name='StartTimeUTC', example='2020-12-12T16:00:00Z'),
}

model DescribeBackupsResponseBody = {
  backups?: {
    backup?: [ 
    {
      backupDBNames?: string(name='BackupDBNames', example='1'),
      backupDownloadURL?: string(name='BackupDownloadURL', example='1'),
      backupEndTime?: string(name='BackupEndTime', example='2020-12-23 17:25:24'),
      backupEndTimeUTC?: string(name='BackupEndTimeUTC', example='2020-12-23T09:25:24Z'),
      backupId?: int32(name='BackupId', example='511876087'),
      backupMethod?: string(name='BackupMethod', example='P'),
      backupMode?: string(name='BackupMode', example='0'),
      backupSize?: string(name='BackupSize', example='0.00'),
      backupStartTime?: string(name='BackupStartTime', example='2020-12-23 17:25:08'),
      backupStartTimeUTC?: string(name='BackupStartTimeUTC', example='2020-12-23T09:25:08Z'),
      backupStatus?: string(name='BackupStatus', example='0'),
      backupType?: string(name='BackupType', example='F'),
    }
  ](name='Backup')
  }(name='Backups'),
  enableStatus?: string(name='EnableStatus', example='enable'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='A93CE373-0FDE-4CCB-9DBA-6700906825ED'),
  totalCount?: int32(name='TotalCount', example='1'),
}

model DescribeBackupsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBackupsResponseBody(name='body'),
}

/**
 * @param request DescribeBackupsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeBackupsResponse
 */
async function describeBackupsWithOptions(request: DescribeBackupsRequest, runtime: Util.RuntimeOptions): DescribeBackupsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.backupId)) {
    query['BackupId'] = request.backupId;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.endTimeUTC)) {
    query['EndTimeUTC'] = request.endTimeUTC;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.startTimeUTC)) {
    query['StartTimeUTC'] = request.startTimeUTC;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBackups',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeBackupsRequest
 * @return DescribeBackupsResponse
 */
async function describeBackups(request: DescribeBackupsRequest): DescribeBackupsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBackupsWithOptions(request, runtime);
}

model DescribeClusterConnectionRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
}

model DescribeClusterConnectionResponseBody = {
  dbType?: string(name='DbType', example='hbaseue'),
  isMultimod?: string(name='IsMultimod', example='true'),
  netType?: string(name='NetType', example='VPC'),
  requestId?: string(name='RequestId', example='70220050-A465-5DCC-8C0C-C38C6E3DB24D'),
  serviceConnAddrs?: {
    serviceConnAddr?: [ 
    {
      connAddrInfo?: {
        connAddr?: string(name='ConnAddr', example='hb-****-proxy-phoenix.hbase.rds.aliyuncs.com'),
        connAddrPort?: string(name='ConnAddrPort', example='8765'),
        netType?: string(name='NetType', example='2'),
      }(name='ConnAddrInfo'),
      connType?: string(name='ConnType', example='PhoenixConnAddr'),
    }
  ](name='ServiceConnAddr')
  }(name='ServiceConnAddrs'),
  slbConnAddrs?: {
    slbConnAddr?: [ 
    {
      connAddrInfo?: {
        connAddr?: string(name='ConnAddr', example='ld-bp150tns0sjxs****-proxy-hbaseue-pub.hbaseue.rds.aliyuncs.com'),
        connAddrPort?: string(name='ConnAddrPort', example='9190'),
        netType?: string(name='NetType', example='0'),
      }(name='ConnAddrInfo'),
      slbType?: string(name='SlbType', example='hbaseue'),
    }
  ](name='SlbConnAddr')
  }(name='SlbConnAddrs'),
  thriftConn?: {
    connAddr?: string(name='ConnAddr', example='hb-bp1u0639js2h7****-proxy-thrift.hbase.rds.aliyuncs.com'),
    connAddrPort?: string(name='ConnAddrPort', example='9099'),
    netType?: string(name='NetType', example='2'),
  }(name='ThriftConn'),
  uiProxyConnAddrInfo?: {
    connAddr?: string(name='ConnAddr', example='ld-bp150tns0sjxs****-master1-001.hbaseue.rds.aliyuncs.com'),
    connAddrPort?: string(name='ConnAddrPort', example='443'),
    netType?: string(name='NetType', example='PUBLIC'),
  }(name='UiProxyConnAddrInfo'),
  vSwitchId?: string(name='VSwitchId', example='vsw-bp1foll427ze3d4ps****'),
  vpcId?: string(name='VpcId', example='vpc-bp15s22y1a7sff5gj****'),
  zkConnAddrs?: {
    zkConnAddr?: [ 
    {
      connAddr?: string(name='ConnAddr', example='ld-bp150tns0sjxs****-master1-001.hbaseue.rds.aliyuncs.com'),
      connAddrPort?: string(name='ConnAddrPort', example='2181'),
      netType?: string(name='NetType', example='2'),
    }
  ](name='ZkConnAddr')
  }(name='ZkConnAddrs'),
}

model DescribeClusterConnectionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeClusterConnectionResponseBody(name='body'),
}

/**
 * @param request DescribeClusterConnectionRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeClusterConnectionResponse
 */
async function describeClusterConnectionWithOptions(request: DescribeClusterConnectionRequest, runtime: Util.RuntimeOptions): DescribeClusterConnectionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeClusterConnection',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeClusterConnectionRequest
 * @return DescribeClusterConnectionResponse
 */
async function describeClusterConnection(request: DescribeClusterConnectionRequest): DescribeClusterConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeClusterConnectionWithOptions(request, runtime);
}

model DescribeColdStorageRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1uoihlf82e8****'),
}

model DescribeColdStorageResponseBody = {
  clusterId?: string(name='ClusterId', example='ld-bp1uoihlf82e8****'),
  coldStorageSize?: string(name='ColdStorageSize', example='800'),
  coldStorageType?: string(name='ColdStorageType', example='BdsColdStorage'),
  coldStorageUseAmount?: string(name='ColdStorageUseAmount', example='20.00'),
  coldStorageUsePercent?: string(name='ColdStorageUsePercent', example='20.00'),
  openStatus?: string(name='OpenStatus', example='open'),
  payType?: string(name='PayType', example='POSTPAY'),
  requestId?: string(name='RequestId', example='DCB9479E-F05F-4D1C-AFB7-C639B87764B7'),
}

model DescribeColdStorageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeColdStorageResponseBody(name='body'),
}

/**
 * @param request DescribeColdStorageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeColdStorageResponse
 */
async function describeColdStorageWithOptions(request: DescribeColdStorageRequest, runtime: Util.RuntimeOptions): DescribeColdStorageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeColdStorage',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeColdStorageRequest
 * @return DescribeColdStorageResponse
 */
async function describeColdStorage(request: DescribeColdStorageRequest): DescribeColdStorageResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeColdStorageWithOptions(request, runtime);
}

model DescribeDBInstanceUsageRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1u0639js2h7****'),
}

model DescribeDBInstanceUsageResponseBody = {
  requestId?: string(name='RequestId', example='A2D841CE-D066-53E8-B9AC-3731DCC85397'),
  result?: string(name='Result', example='{\\\\"disk_usage_record\\\\":{\\\\"disk_used\\\\":\\\\"0.9GB\\\\",\\\\"disk_total\\\\":\\\\"1156.1GB\\\\",\\\\"usage_rate\\\\":\\\\"1%\\\\"}}'),
}

model DescribeDBInstanceUsageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeDBInstanceUsageResponseBody(name='body'),
}

/**
 * @param request DescribeDBInstanceUsageRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeDBInstanceUsageResponse
 */
async function describeDBInstanceUsageWithOptions(request: DescribeDBInstanceUsageRequest, runtime: Util.RuntimeOptions): DescribeDBInstanceUsageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeDBInstanceUsage',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeDBInstanceUsageRequest
 * @return DescribeDBInstanceUsageResponse
 */
async function describeDBInstanceUsage(request: DescribeDBInstanceUsageRequest): DescribeDBInstanceUsageResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDBInstanceUsageWithOptions(request, runtime);
}

model DescribeDeletedInstancesRequest {
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  regionId?: string(name='RegionId', example='cn-hangzhou'),
}

model DescribeDeletedInstancesResponseBody = {
  instances?: {
    instance?: [ 
    {
      clusterType?: string(name='ClusterType', example='cluster'),
      createdTime?: string(name='CreatedTime', example='2020-11-02T07:16:07Z'),
      deleteTime?: string(name='DeleteTime', example='2020-11-02T07:27:24Z'),
      engine?: string(name='Engine', example='hbase'),
      instanceId?: string(name='InstanceId', example='hb-bp10q7n2zdw12xxxx'),
      instanceName?: string(name='InstanceName', example='e2e-test'),
      majorVersion?: string(name='MajorVersion', example='2.0'),
      moduleStackVersion?: string(name='ModuleStackVersion', example='null'),
      parentId?: string(name='ParentId', example='null'),
      regionId?: string(name='RegionId', example='cn-hangzhou'),
      status?: string(name='Status', example='DELETED'),
      zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
    }
  ](name='Instance')
  }(name='Instances'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='0CAC5702-C862-44C0-AD54-C9CE70F4B246'),
  totalCount?: long(name='TotalCount', example='1'),
}

model DescribeDeletedInstancesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeDeletedInstancesResponseBody(name='body'),
}

/**
 * @param request DescribeDeletedInstancesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeDeletedInstancesResponse
 */
async function describeDeletedInstancesWithOptions(request: DescribeDeletedInstancesRequest, runtime: Util.RuntimeOptions): DescribeDeletedInstancesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeDeletedInstances',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeDeletedInstancesRequest
 * @return DescribeDeletedInstancesResponse
 */
async function describeDeletedInstances(request: DescribeDeletedInstancesRequest): DescribeDeletedInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDeletedInstancesWithOptions(request, runtime);
}

model DescribeDiskWarningLineRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1bl7iqzkahmyxxxx'),
}

model DescribeDiskWarningLineResponseBody = {
  requestId?: string(name='RequestId', example='08DF8283-D290-4107-931E-7913D6D3480D'),
  warningLine?: string(name='WarningLine', example='80'),
}

model DescribeDiskWarningLineResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeDiskWarningLineResponseBody(name='body'),
}

/**
 * @param request DescribeDiskWarningLineRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeDiskWarningLineResponse
 */
async function describeDiskWarningLineWithOptions(request: DescribeDiskWarningLineRequest, runtime: Util.RuntimeOptions): DescribeDiskWarningLineResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeDiskWarningLine',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeDiskWarningLineRequest
 * @return DescribeDiskWarningLineResponse
 */
async function describeDiskWarningLine(request: DescribeDiskWarningLineRequest): DescribeDiskWarningLineResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDiskWarningLineWithOptions(request, runtime);
}

model DescribeEndpointsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}

model DescribeEndpointsResponseBody = {
  connAddrs?: {
    connAddrInfo?: [ 
    {
      connAddr?: string(name='ConnAddr', example='****'),
      connAddrPort?: string(name='ConnAddrPort', example='****'),
      connType?: string(name='ConnType', example='zkConn'),
      netType?: string(name='NetType', example='2'),
    }
  ](name='ConnAddrInfo')
  }(name='ConnAddrs'),
  engine?: string(name='Engine', example='hbaseue'),
  netType?: string(name='NetType', example='VPC'),
  requestId?: string(name='RequestId', example='F072593C-5234-5B56-9F63-3C7A3AD85D66'),
  vSwitchId?: string(name='VSwitchId', example='vsw-bp1foll427ze3d4ps****'),
  vpcId?: string(name='VpcId', example='vpc-bp15s22y1a7sff5gj****'),
}

model DescribeEndpointsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeEndpointsResponseBody(name='body'),
}

/**
 * @param request DescribeEndpointsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeEndpointsResponse
 */
async function describeEndpointsWithOptions(request: DescribeEndpointsRequest, runtime: Util.RuntimeOptions): DescribeEndpointsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeEndpoints',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeEndpointsRequest
 * @return DescribeEndpointsResponse
 */
async function describeEndpoints(request: DescribeEndpointsRequest): DescribeEndpointsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeEndpointsWithOptions(request, runtime);
}

model DescribeInstanceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}

model DescribeInstanceResponseBody = {
  autoRenewal?: boolean(name='AutoRenewal', example='false'),
  backupStatus?: string(name='BackupStatus', example='open'),
  clusterId?: string(name='ClusterId', example='ld-bp150tns0sjxs****'),
  clusterName?: string(name='ClusterName', example='testhbase'),
  clusterType?: string(name='ClusterType', example='cluster'),
  coldStorageSize?: int32(name='ColdStorageSize', example='800'),
  coldStorageStatus?: string(name='ColdStorageStatus', example='open'),
  confirmMaintainTime?: string(name='ConfirmMaintainTime', example='true'),
  coreDiskCount?: string(name='CoreDiskCount', example='4'),
  coreDiskSize?: int32(name='CoreDiskSize', example='100'),
  coreDiskType?: string(name='CoreDiskType', example='cloud_ssd'),
  coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn2.2xlarge'),
  coreNodeCount?: int32(name='CoreNodeCount', example='2'),
  createdTime?: string(name='CreatedTime', example='2021-07-19T11:23:22'),
  createdTimeUTC?: string(name='CreatedTimeUTC', example='2021-07-19T03:23:22Z'),
  duration?: int32(name='Duration', example='12'),
  enableHbaseProxy?: boolean(name='EnableHbaseProxy', description='This parameter is required.', example='false'),
  encryptionKey?: string(name='EncryptionKey', example='0d2470df-da7b-4786-b981-9a164dae****'),
  encryptionType?: string(name='EncryptionType', example='NoEncryption'),
  engine?: string(name='Engine', example='hbaseue'),
  expireTime?: string(name='ExpireTime', example='2022-02-24T00:00:00'),
  expireTimeUTC?: string(name='ExpireTimeUTC', example='2022-02-23T16:00:00Z'),
  instanceId?: string(name='InstanceId', example='ld-bp150tns0sjxs****'),
  instanceName?: string(name='InstanceName', example='testhbase'),
  isDeletionProtection?: boolean(name='IsDeletionProtection', example='false'),
  isHa?: boolean(name='IsHa', example='true'),
  isLatestVersion?: boolean(name='IsLatestVersion', example='true'),
  isMultiModel?: boolean(name='IsMultiModel', example='true'),
  lproxyMinorVersion?: string(name='LproxyMinorVersion', example='2.3.2'),
  maintainEndTime?: string(name='MaintainEndTime', example='22:00Z'),
  maintainStartTime?: string(name='MaintainStartTime', example='18:00Z'),
  majorVersion?: string(name='MajorVersion', example='2.0'),
  masterDiskSize?: int32(name='MasterDiskSize', example='0'),
  masterDiskType?: string(name='MasterDiskType', example='cloud_efficiency'),
  masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn2.large'),
  masterNodeCount?: int32(name='MasterNodeCount', example='2'),
  minorVersion?: string(name='MinorVersion', example='2.2.9.1'),
  moduleId?: int32(name='ModuleId', example='0'),
  moduleStackVersion?: string(name='ModuleStackVersion', example='phoenxi:4.0'),
  needUpgrade?: boolean(name='NeedUpgrade', example='false'),
  needUpgradeComps?: {
    comps?: [ string ](name='Comps')
  }(name='NeedUpgradeComps'),
  networkType?: string(name='NetworkType', example='VPC'),
  parentId?: string(name='ParentId', example='ld-uf699153o1m2l****'),
  payType?: string(name='PayType', example='Prepaid'),
  regionId?: string(name='RegionId', example='cn-hangzhou'),
  requestId?: string(name='RequestId', example='3F429923-B6F6-52C5-9C2A-5B8A8C6BBA66'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-acfmyiu4ekp****'),
  status?: string(name='Status', example='ACTIVATION'),
  tags?: {
    tag?: [ 
    {
      key?: string(name='Key', example='test_key'),
      value?: string(name='Value', example='test_value'),
    }
  ](name='Tag')
  }(name='Tags'),
  taskProgress?: string(name='TaskProgress', example='25.00'),
  taskStatus?: string(name='TaskStatus'),
  vpcId?: string(name='VpcId', example='vpc-bp15s22y1a7sff5gj****'),
  vswitchId?: string(name='VswitchId', example='vsw-bp1foll427ze3d4ps****'),
  zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}

model DescribeInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInstanceResponseBody(name='body'),
}

/**
 * @param request DescribeInstanceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeInstanceResponse
 */
async function describeInstanceWithOptions(request: DescribeInstanceRequest, runtime: Util.RuntimeOptions): DescribeInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInstance',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeInstanceRequest
 * @return DescribeInstanceResponse
 */
async function describeInstance(request: DescribeInstanceRequest): DescribeInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInstanceWithOptions(request, runtime);
}

model DescribeInstanceTypeRequest {
  instanceType?: string(name='InstanceType', example='hbase.n2.4xlarge'),
}

model DescribeInstanceTypeResponseBody = {
  instanceTypeSpecList?: {
    instanceTypeSpec?: [ 
    {
      cpuSize?: long(name='CpuSize', example='8'),
      instanceType?: string(name='InstanceType', example='hbase.n2.4xlarge'),
      memSize?: long(name='MemSize', example='16'),
    }
  ](name='InstanceTypeSpec')
  }(name='InstanceTypeSpecList'),
  requestId?: string(name='RequestId', example='DD23BBB4-64C2-42A4-B2E2-7E56C7AA815A'),
}

model DescribeInstanceTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInstanceTypeResponseBody(name='body'),
}

/**
 * @param request DescribeInstanceTypeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeInstanceTypeResponse
 */
async function describeInstanceTypeWithOptions(request: DescribeInstanceTypeRequest, runtime: Util.RuntimeOptions): DescribeInstanceTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceType)) {
    query['InstanceType'] = request.instanceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInstanceType',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeInstanceTypeRequest
 * @return DescribeInstanceTypeResponse
 */
async function describeInstanceType(request: DescribeInstanceTypeRequest): DescribeInstanceTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInstanceTypeWithOptions(request, runtime);
}

model DescribeInstancesRequest {
  clusterId?: string(name='ClusterId', example='hb-bp1u0639js2h7****'),
  clusterName?: string(name='ClusterName', example='test'),
  dbType?: string(name='DbType', example='hbase'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  regionId?: string(name='RegionId', example='cn-hangzhou'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-4f51d54g5****'),
  tag?: [ 
    {
      key?: string(name='Key', example='key'),
      value?: string(name='Value', example='value'),
    }
  ](name='Tag'),
}

model DescribeInstancesResponseBody = {
  instances?: {
    instance?: [ 
    {
      autoRenewal?: boolean(name='AutoRenewal', example='false'),
      backupStatus?: string(name='BackupStatus', example='open'),
      clusterId?: string(name='ClusterId', example='hb-bp1u0639js2h7****'),
      clusterName?: string(name='ClusterName', example='test'),
      clusterType?: string(name='ClusterType', example='cluster'),
      coldStorageStatus?: string(name='ColdStorageStatus', example='open'),
      coreDiskCount?: string(name='CoreDiskCount', example='2'),
      coreDiskSize?: int32(name='CoreDiskSize', example='100'),
      coreDiskType?: string(name='CoreDiskType', example='cloud_efficiency'),
      coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
      coreNodeCount?: int32(name='CoreNodeCount', example='2'),
      createdTime?: string(name='CreatedTime', example='2019-09-12T14:40:46'),
      createdTimeUTC?: string(name='CreatedTimeUTC', example='2019-09-12T14:40:46Z'),
      duration?: int32(name='Duration', example='12'),
      engine?: string(name='Engine', example='hbase'),
      expireTime?: string(name='ExpireTime', example='2019-10-12T14:40:46'),
      expireTimeUTC?: string(name='ExpireTimeUTC', example='2019-10-12T14:40:46Z'),
      instanceId?: string(name='InstanceId', example='hb-bp1u0639js2h7****'),
      instanceName?: string(name='InstanceName', example='test'),
      isDeletionProtection?: boolean(name='IsDeletionProtection', example='true'),
      isHa?: boolean(name='IsHa', example='true'),
      majorVersion?: string(name='MajorVersion', example='2.0'),
      masterDiskSize?: int32(name='MasterDiskSize', example='100'),
      masterDiskType?: string(name='MasterDiskType', example='cloud_efficiency'),
      masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
      masterNodeCount?: int32(name='MasterNodeCount', example='2'),
      moduleId?: int32(name='ModuleId', example='0'),
      moduleStackVersion?: string(name='ModuleStackVersion', example='1.0'),
      networkType?: string(name='NetworkType', example='VPC'),
      parentId?: string(name='ParentId', example='2980****2123'),
      payType?: string(name='PayType', example='Prepaid'),
      regionId?: string(name='RegionId', example='cn-hangzhou'),
      resourceGroupId?: string(name='ResourceGroupId', example='rg-4f51d54g5****'),
      status?: string(name='Status', example='ACTIVATION'),
      tags?: {
        tag?: [ 
        {
          key?: string(name='Key', example='test-key'),
          value?: string(name='Value', example='test-value'),
        }
      ](name='Tag')
      }(name='Tags'),
      vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eoghz*****'),
      vswitchId?: string(name='VswitchId', example='vsw-bp191ipotq****dbqf'),
      zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
    }
  ](name='Instance')
  }(name='Instances'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='EBECBF12-2E34-41BE-8DE9-FC3700D4****'),
  totalCount?: long(name='TotalCount', example='18'),
}

model DescribeInstancesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInstancesResponseBody(name='body'),
}

/**
 * @param request DescribeInstancesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeInstancesResponse
 */
async function describeInstancesWithOptions(request: DescribeInstancesRequest, runtime: Util.RuntimeOptions): DescribeInstancesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.clusterName)) {
    query['ClusterName'] = request.clusterName;
  }
  if (!Util.isUnset(request.dbType)) {
    query['DbType'] = request.dbType;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceGroupId)) {
    query['ResourceGroupId'] = request.resourceGroupId;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInstances',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeInstancesRequest
 * @return DescribeInstancesResponse
 */
async function describeInstances(request: DescribeInstancesRequest): DescribeInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInstancesWithOptions(request, runtime);
}

model DescribeIpWhitelistRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}

model DescribeIpWhitelistResponseBody = {
  groups?: {
    group?: [ 
    {
      groupName?: string(name='GroupName', example='default'),
      ipList?: {
        ip?: [ string ](name='Ip')
      }(name='IpList'),
      ipVersion?: int32(name='IpVersion', example='4'),
    }
  ](name='Group')
  }(name='Groups'),
  requestId?: string(name='RequestId', example='AFAA617B-3268-5883-982B-DB8EC8CC1F1B'),
}

model DescribeIpWhitelistResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeIpWhitelistResponseBody(name='body'),
}

/**
 * @param request DescribeIpWhitelistRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeIpWhitelistResponse
 */
async function describeIpWhitelistWithOptions(request: DescribeIpWhitelistRequest, runtime: Util.RuntimeOptions): DescribeIpWhitelistResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeIpWhitelist',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeIpWhitelistRequest
 * @return DescribeIpWhitelistResponse
 */
async function describeIpWhitelist(request: DescribeIpWhitelistRequest): DescribeIpWhitelistResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeIpWhitelistWithOptions(request, runtime);
}

model DescribeMultiZoneAvailableRegionsRequest {
  acceptLanguage?: string(name='AcceptLanguage', example='zh-CN'),
}

model DescribeMultiZoneAvailableRegionsResponseBody = {
  regions?: {
    region?: [ 
    {
      availableCombines?: {
        availableCombine?: [ 
        {
          id?: string(name='Id', example='cn-shenzhen-****-aliyun'),
          zones?: {
            zone?: [ string ](name='Zone')
          }(name='Zones'),
        }
      ](name='AvailableCombine')
      }(name='AvailableCombines'),
      localName?: string(name='LocalName'),
      regionEndpoint?: string(name='RegionEndpoint', example='hbase.aliyuncs.com'),
      regionId?: string(name='RegionId', example='cn-shenzhen'),
    }
  ](name='Region')
  }(name='Regions'),
  requestId?: string(name='RequestId', example='F03BB273-45EE-4B6C-A329-A6E6A8D15856'),
}

model DescribeMultiZoneAvailableRegionsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeMultiZoneAvailableRegionsResponseBody(name='body'),
}

/**
 * @param request DescribeMultiZoneAvailableRegionsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeMultiZoneAvailableRegionsResponse
 */
async function describeMultiZoneAvailableRegionsWithOptions(request: DescribeMultiZoneAvailableRegionsRequest, runtime: Util.RuntimeOptions): DescribeMultiZoneAvailableRegionsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.acceptLanguage)) {
    query['AcceptLanguage'] = request.acceptLanguage;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeMultiZoneAvailableRegions',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeMultiZoneAvailableRegionsRequest
 * @return DescribeMultiZoneAvailableRegionsResponse
 */
async function describeMultiZoneAvailableRegions(request: DescribeMultiZoneAvailableRegionsRequest): DescribeMultiZoneAvailableRegionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMultiZoneAvailableRegionsWithOptions(request, runtime);
}

model DescribeMultiZoneAvailableResourceRequest {
  chargeType?: string(name='ChargeType', description='This parameter is required.', example='Prepaid'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  zoneCombination?: string(name='ZoneCombination', example='cn-hangzhou-bef-aliyun'),
}

model DescribeMultiZoneAvailableResourceResponseBody = {
  availableZones?: {
    availableZone?: [ 
    {
      masterResources?: {
        masterResource?: [ 
        {
          instanceType?: string(name='InstanceType', example='hbase.sn2.large'),
          instanceTypeDetail?: {
            cpu?: int32(name='Cpu', example='4'),
            mem?: int32(name='Mem', example='16'),
          }(name='InstanceTypeDetail'),
        }
      ](name='MasterResource')
      }(name='MasterResources'),
      regionId?: string(name='RegionId', example='cn-hangzhou'),
      supportedEngines?: {
        supportedEngine?: [ 
        {
          engine?: string(name='Engine', example='hbaseue'),
          supportedEngineVersions?: {
            supportedEngineVersion?: [ 
            {
              supportedCategories?: {
                supportedCategories?: [ 
                {
                  category?: string(name='Category', example='cluster'),
                  supportedStorageTypes?: {
                    supportedStorageType?: [ 
                    {
                      coreResources?: {
                        coreResource?: [ 
                        {
                          DBInstanceStorageRange?: {
                            maxSize?: int32(name='MaxSize', example='64000'),
                            minSize?: int32(name='MinSize', example='400'),
                            stepSize?: int32(name='StepSize', example='40'),
                          }(name='DBInstanceStorageRange'),
                          instanceType?: string(name='InstanceType', example='hbase.sn2.2xlarge'),
                          instanceTypeDetail?: {
                            cpu?: int32(name='Cpu', example='32'),
                            mem?: int32(name='Mem', example='8'),
                          }(name='InstanceTypeDetail'),
                          maxCoreCount?: int32(name='MaxCoreCount', example='30'),
                        }
                      ](name='CoreResource')
                      }(name='CoreResources'),
                      storageType?: string(name='StorageType', example='cloud_efficiency'),
                    }
                  ](name='SupportedStorageType')
                  }(name='SupportedStorageTypes'),
                }
              ](name='SupportedCategories')
              }(name='SupportedCategories'),
              version?: string(name='Version', example='2.0'),
            }
          ](name='SupportedEngineVersion')
          }(name='SupportedEngineVersions'),
        }
      ](name='SupportedEngine')
      }(name='SupportedEngines'),
      zoneCombination?: string(name='ZoneCombination', example='cn-hangzhou-bef-aliyun'),
    }
  ](name='AvailableZone')
  }(name='AvailableZones'),
  requestId?: string(name='RequestId', example='B2EEBBA9-C627-4415-81A0-B77BC54F1D52'),
}

model DescribeMultiZoneAvailableResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeMultiZoneAvailableResourceResponseBody(name='body'),
}

/**
 * @param request DescribeMultiZoneAvailableResourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeMultiZoneAvailableResourceResponse
 */
async function describeMultiZoneAvailableResourceWithOptions(request: DescribeMultiZoneAvailableResourceRequest, runtime: Util.RuntimeOptions): DescribeMultiZoneAvailableResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.chargeType)) {
    query['ChargeType'] = request.chargeType;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.zoneCombination)) {
    query['ZoneCombination'] = request.zoneCombination;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeMultiZoneAvailableResource',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeMultiZoneAvailableResourceRequest
 * @return DescribeMultiZoneAvailableResourceResponse
 */
async function describeMultiZoneAvailableResource(request: DescribeMultiZoneAvailableResourceRequest): DescribeMultiZoneAvailableResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMultiZoneAvailableResourceWithOptions(request, runtime);
}

model DescribeMultiZoneClusterRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-t4nn71xa0yn****'),
}

model DescribeMultiZoneClusterResponseBody = {
  arbiterVSwitchIds?: string(name='ArbiterVSwitchIds', example='vsw-t4nax9mp3wk0czn****'),
  arbiterZoneId?: string(name='ArbiterZoneId', example='ap-southeast-1c'),
  autoRenewal?: boolean(name='AutoRenewal', example='false'),
  clusterId?: string(name='ClusterId', example='ld-t4nn71xa0yn****'),
  clusterName?: string(name='ClusterName', example='mz_test'),
  coldStorageSize?: int32(name='ColdStorageSize'),
  coreDiskCount?: string(name='CoreDiskCount', example='4'),
  coreDiskSize?: int32(name='CoreDiskSize', example='100'),
  coreDiskType?: string(name='CoreDiskType', example='cloud_efficiency'),
  coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
  coreNodeCount?: int32(name='CoreNodeCount', example='6'),
  createdTime?: string(name='CreatedTime', example='2020-10-15T18:04:52'),
  createdTimeUTC?: string(name='CreatedTimeUTC', example='2020-10-15T10:04:52Z'),
  duration?: int32(name='Duration', example='1'),
  encryptionKey?: string(name='EncryptionKey', example='2a****'),
  encryptionType?: string(name='EncryptionType', example='CloudDisk'),
  engine?: string(name='Engine', example='hbaseue'),
  expireTime?: string(name='ExpireTime', example='2020-11-16T08:00:00'),
  expireTimeUTC?: string(name='ExpireTimeUTC', example='2020-11-16T00:00:00Z'),
  instanceId?: string(name='InstanceId', example='ld-t4nn71xa0yn****'),
  instanceName?: string(name='InstanceName', example='mz_test'),
  isDeletionProtection?: boolean(name='IsDeletionProtection', example='false'),
  logDiskCount?: string(name='LogDiskCount', example='4'),
  logDiskSize?: int32(name='LogDiskSize', example='100'),
  logDiskType?: string(name='LogDiskType', example='cloud_efficiency'),
  logInstanceType?: string(name='LogInstanceType', example='hbase.sn1.large'),
  logNodeCount?: int32(name='LogNodeCount', example='4'),
  maintainEndTime?: string(name='MaintainEndTime', example='06:00:00'),
  maintainStartTime?: string(name='MaintainStartTime', example='02:00:00'),
  majorVersion?: string(name='MajorVersion', example='2.0'),
  masterDiskSize?: int32(name='MasterDiskSize', example='50'),
  masterDiskType?: string(name='MasterDiskType', example='cloud_efficiency'),
  masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
  masterNodeCount?: int32(name='MasterNodeCount', example='2'),
  moduleId?: int32(name='ModuleId', example='0'),
  moduleStackVersion?: string(name='ModuleStackVersion', example='2.0'),
  multiZoneCombination?: string(name='MultiZoneCombination', example='ap-southeast-1-abc-aliyun'),
  multiZoneInstanceModels?: {
    multiZoneInstanceModel?: [ 
    {
      hdfsMinorVersion?: string(name='HdfsMinorVersion'),
      insName?: string(name='InsName', example='ld-t4nn71xa0yn****-az-a'),
      isHdfsLatestVersion?: string(name='IsHdfsLatestVersion'),
      isLatestVersion?: boolean(name='IsLatestVersion', example='true'),
      latestHdfsMinorVersion?: string(name='LatestHdfsMinorVersion'),
      latestMinorVersion?: string(name='LatestMinorVersion'),
      minorVersion?: string(name='MinorVersion', example='2.1.24'),
      role?: string(name='Role', example='primary'),
      status?: string(name='Status', example='ACTIVATION'),
    }
  ](name='MultiZoneInstanceModel')
  }(name='MultiZoneInstanceModels'),
  networkType?: string(name='NetworkType', example='VPC'),
  parentId?: string(name='ParentId', example='ld-fls1gf31y5s35****'),
  payType?: string(name='PayType', example='Prepaid'),
  primaryVSwitchIds?: string(name='PrimaryVSwitchIds', example='vsw-t4n3s1zd2gtidg****'),
  primaryZoneId?: string(name='PrimaryZoneId', example='ap-southeast-1a'),
  regionId?: string(name='RegionId', example='ap-southeast-1'),
  requestId?: string(name='RequestId', example='A02C0E6D-3A47-4FA0-BA7E-60793CE256DA'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-lk51f5fer315e****'),
  standbyVSwitchIds?: string(name='StandbyVSwitchIds', example='vsw-t4nvvk7xur3rdi****'),
  standbyZoneId?: string(name='StandbyZoneId', example='ap-southeast-1b'),
  status?: string(name='Status', example='ACTIVATION'),
  tags?: {
    tag?: [ 
    {
      key?: string(name='Key', example='test_key'),
      value?: string(name='Value', example='test_value'),
    }
  ](name='Tag')
  }(name='Tags'),
  taskProgress?: string(name='TaskProgress'),
  taskStatus?: string(name='TaskStatus'),
  vpcId?: string(name='VpcId', example='vpc-t4nx81tmlixcq5****'),
}

model DescribeMultiZoneClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeMultiZoneClusterResponseBody(name='body'),
}

/**
 * @param request DescribeMultiZoneClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeMultiZoneClusterResponse
 */
async function describeMultiZoneClusterWithOptions(request: DescribeMultiZoneClusterRequest, runtime: Util.RuntimeOptions): DescribeMultiZoneClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeMultiZoneCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeMultiZoneClusterRequest
 * @return DescribeMultiZoneClusterResponse
 */
async function describeMultiZoneCluster(request: DescribeMultiZoneClusterRequest): DescribeMultiZoneClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMultiZoneClusterWithOptions(request, runtime);
}

model DescribeRecoverableTimeRangeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
}

model DescribeRecoverableTimeRangeResponseBody = {
  requestId?: string(name='RequestId', example='A1A51D18-96DC-465C-9F1B-47180CA22524'),
  timeBegin?: string(name='TimeBegin', example='2020-10-26T18:02:03Z'),
  timeEnd?: string(name='TimeEnd', example='2020-11-05T01:20:31Z'),
}

model DescribeRecoverableTimeRangeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRecoverableTimeRangeResponseBody(name='body'),
}

/**
 * @param request DescribeRecoverableTimeRangeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRecoverableTimeRangeResponse
 */
async function describeRecoverableTimeRangeWithOptions(request: DescribeRecoverableTimeRangeRequest, runtime: Util.RuntimeOptions): DescribeRecoverableTimeRangeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRecoverableTimeRange',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRecoverableTimeRangeRequest
 * @return DescribeRecoverableTimeRangeResponse
 */
async function describeRecoverableTimeRange(request: DescribeRecoverableTimeRangeRequest): DescribeRecoverableTimeRangeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRecoverableTimeRangeWithOptions(request, runtime);
}

model DescribeRegionsRequest {
  acceptLanguage?: string(name='AcceptLanguage', example='zh-CN'),
  engine?: string(name='Engine', example='hbase'),
}

model DescribeRegionsResponseBody = {
  regions?: {
    region?: [ 
    {
      localName?: string(name='LocalName'),
      regionEndpoint?: string(name='RegionEndpoint', example='hbase.aliyuncs.com'),
      regionId?: string(name='RegionId', example='cn-hangzhou'),
      zones?: {
        zone?: [ 
        {
          id?: string(name='Id', example='cn-hangzhou-b'),
        }
      ](name='Zone')
      }(name='Zones'),
    }
  ](name='Region')
  }(name='Regions'),
  requestId?: string(name='RequestId', example='14D3924C-4FD8-4EE9-9B34-DA949D104F42'),
}

model DescribeRegionsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRegionsResponseBody(name='body'),
}

/**
 * @param request DescribeRegionsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRegionsResponse
 */
async function describeRegionsWithOptions(request: DescribeRegionsRequest, runtime: Util.RuntimeOptions): DescribeRegionsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.acceptLanguage)) {
    query['AcceptLanguage'] = request.acceptLanguage;
  }
  if (!Util.isUnset(request.engine)) {
    query['Engine'] = request.engine;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRegions',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRegionsRequest
 * @return DescribeRegionsResponse
 */
async function describeRegions(request: DescribeRegionsRequest): DescribeRegionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRegionsWithOptions(request, runtime);
}

model DescribeRestoreFullDetailsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}

model DescribeRestoreFullDetailsResponseBody = {
  requestId?: string(name='RequestId', example='CFE525CF-C691-4140-A981-D004DAA7A840'),
  restoreFull?: {
    dataSize?: string(name='DataSize', example='1.2 kB'),
    fail?: int32(name='Fail', example='0'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    restoreFullDetails?: {
      restoreFullDetail?: [ 
      {
        dataSize?: string(name='DataSize', example='1.2 kB'),
        endTime?: string(name='EndTime', example='2020-11-05T06:45:51Z'),
        message?: string(name='Message', example='null'),
        process?: string(name='Process', example='14/14'),
        speed?: string(name='Speed', example='0.00 MB/s'),
        startTime?: string(name='StartTime', example='2020-11-05T06:45:45Z'),
        state?: string(name='State', example='SUCCEEDED'),
        table?: string(name='Table', example='default:test1'),
      }
    ](name='RestoreFullDetail')
    }(name='RestoreFullDetails'),
    speed?: string(name='Speed', example='0.00 MB/s'),
    succeed?: int32(name='Succeed', example='1'),
    total?: long(name='Total', example='1'),
  }(name='RestoreFull'),
}

model DescribeRestoreFullDetailsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRestoreFullDetailsResponseBody(name='body'),
}

/**
 * @param request DescribeRestoreFullDetailsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRestoreFullDetailsResponse
 */
async function describeRestoreFullDetailsWithOptions(request: DescribeRestoreFullDetailsRequest, runtime: Util.RuntimeOptions): DescribeRestoreFullDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.restoreRecordId)) {
    query['RestoreRecordId'] = request.restoreRecordId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRestoreFullDetails',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRestoreFullDetailsRequest
 * @return DescribeRestoreFullDetailsResponse
 */
async function describeRestoreFullDetails(request: DescribeRestoreFullDetailsRequest): DescribeRestoreFullDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRestoreFullDetailsWithOptions(request, runtime);
}

model DescribeRestoreIncrDetailRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eyf188hw481xxxx'),
  restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}

model DescribeRestoreIncrDetailResponseBody = {
  requestId?: string(name='RequestId', example='D0FE2717-E194-465A-B27B-7373F96E580B'),
  restoreIncrDetail?: {
    endTime?: string(name='EndTime', example='2020-11-05T06:45:44Z'),
    process?: string(name='Process', example='0/0'),
    restoreDelay?: string(name='RestoreDelay', example='0 ms'),
    restoreStartTs?: string(name='RestoreStartTs', example='2020-11-02T18:00:00Z'),
    restoredTs?: string(name='RestoredTs', example='\\\\"\\\\"'),
    startTime?: string(name='StartTime', example='2020-11-05T06:45:44Z'),
    state?: string(name='State', example='SUCCEEDED'),
  }(name='RestoreIncrDetail'),
}

model DescribeRestoreIncrDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRestoreIncrDetailResponseBody(name='body'),
}

/**
 * @param request DescribeRestoreIncrDetailRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRestoreIncrDetailResponse
 */
async function describeRestoreIncrDetailWithOptions(request: DescribeRestoreIncrDetailRequest, runtime: Util.RuntimeOptions): DescribeRestoreIncrDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.restoreRecordId)) {
    query['RestoreRecordId'] = request.restoreRecordId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRestoreIncrDetail',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRestoreIncrDetailRequest
 * @return DescribeRestoreIncrDetailResponse
 */
async function describeRestoreIncrDetail(request: DescribeRestoreIncrDetailRequest): DescribeRestoreIncrDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRestoreIncrDetailWithOptions(request, runtime);
}

model DescribeRestoreSchemaDetailsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}

model DescribeRestoreSchemaDetailsResponseBody = {
  requestId?: string(name='RequestId', example='BC682A80-7677-4294-975C-CFEA425381DE'),
  restoreSchema?: {
    fail?: int32(name='Fail', example='0'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    restoreSchemaDetails?: {
      restoreSchemaDetail?: [ 
      {
        endTime?: string(name='EndTime', example='2020-11-05T06:45:18Z'),
        message?: string(name='Message', example='null'),
        startTime?: string(name='StartTime', example='2020-11-05T06:45:14Z'),
        state?: string(name='State', example='SUCCEEDED'),
        table?: string(name='Table', example='default:test1'),
      }
    ](name='RestoreSchemaDetail')
    }(name='RestoreSchemaDetails'),
    succeed?: int32(name='Succeed', example='1'),
    total?: long(name='Total', example='1'),
  }(name='RestoreSchema'),
}

model DescribeRestoreSchemaDetailsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRestoreSchemaDetailsResponseBody(name='body'),
}

/**
 * @param request DescribeRestoreSchemaDetailsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRestoreSchemaDetailsResponse
 */
async function describeRestoreSchemaDetailsWithOptions(request: DescribeRestoreSchemaDetailsRequest, runtime: Util.RuntimeOptions): DescribeRestoreSchemaDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.restoreRecordId)) {
    query['RestoreRecordId'] = request.restoreRecordId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRestoreSchemaDetails',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRestoreSchemaDetailsRequest
 * @return DescribeRestoreSchemaDetailsResponse
 */
async function describeRestoreSchemaDetails(request: DescribeRestoreSchemaDetailsRequest): DescribeRestoreSchemaDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRestoreSchemaDetailsWithOptions(request, runtime);
}

model DescribeRestoreSummaryRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
}

model DescribeRestoreSummaryResponseBody = {
  hasMoreRestoreRecord?: int32(name='HasMoreRestoreRecord', example='0'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='AE639ED7-F0F3-4A71-911E-CF8EC088816E'),
  rescords?: {
    rescord?: [ 
    {
      bulkLoadProcess?: string(name='BulkLoadProcess', example='1/1'),
      createTime?: string(name='CreateTime', example='2020-11-05T06:45:14Z'),
      finishTime?: string(name='FinishTime', example='2020-11-05T06:45:51Z'),
      hfileRestoreProcess?: string(name='HfileRestoreProcess', example='1/1'),
      logProcess?: string(name='LogProcess', example='0/0'),
      recordId?: string(name='RecordId', example='20201105144514'),
      schemaProcess?: string(name='SchemaProcess', example='1/1'),
      status?: string(name='Status', example='SUCCEEDED'),
    }
  ](name='Rescord')
  }(name='Rescords'),
  total?: int32(name='Total', example='1'),
}

model DescribeRestoreSummaryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRestoreSummaryResponseBody(name='body'),
}

/**
 * @param request DescribeRestoreSummaryRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRestoreSummaryResponse
 */
async function describeRestoreSummaryWithOptions(request: DescribeRestoreSummaryRequest, runtime: Util.RuntimeOptions): DescribeRestoreSummaryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRestoreSummary',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRestoreSummaryRequest
 * @return DescribeRestoreSummaryResponse
 */
async function describeRestoreSummary(request: DescribeRestoreSummaryRequest): DescribeRestoreSummaryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRestoreSummaryWithOptions(request, runtime);
}

model DescribeRestoreTablesRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  restoreRecordId?: string(name='RestoreRecordId', description='This parameter is required.', example='2020110514xxxx'),
}

model DescribeRestoreTablesResponseBody = {
  requestId?: string(name='RequestId', example='18D9CC47-D913-48BF-AB6B-4FA9B28FBDB1'),
  restoreFull?: {
    dataSize?: string(name='DataSize', example='1.2 kB'),
    fail?: int32(name='Fail', example='0'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    restoreFullDetails?: {
      restoreFullDetail?: [ 
      {
        dataSize?: string(name='DataSize', example='1.2 kB'),
        endTime?: string(name='EndTime', example='2020-11-05T06:45:51Z'),
        message?: string(name='Message', example='“”'),
        process?: string(name='Process', example='14/14'),
        speed?: string(name='Speed', example='0.00 MB/s'),
        startTime?: string(name='StartTime', example='2020-11-05T06:45:45Z'),
        state?: string(name='State', example='SUCCEEDED'),
        table?: string(name='Table', example='default:test1'),
      }
    ](name='RestoreFullDetail')
    }(name='RestoreFullDetails'),
    speed?: string(name='Speed', example='0.00 MB/s'),
    succeed?: int32(name='Succeed', example='1'),
    total?: long(name='Total', example='1'),
  }(name='RestoreFull'),
  restoreIncrDetail?: {
    endTime?: string(name='EndTime', example='2020-11-05T06:45:44Z'),
    process?: string(name='Process', example='0/0'),
    restoreDelay?: string(name='RestoreDelay', example='0 ms'),
    restoreStartTs?: string(name='RestoreStartTs', example='2020-11-02T18:00:00Z'),
    restoredTs?: string(name='RestoredTs', example='“”'),
    startTime?: string(name='StartTime', example='2020-11-05T06:45:44Z'),
    state?: string(name='State', example='SUCCEEDED'),
  }(name='RestoreIncrDetail'),
  restoreSchema?: {
    fail?: int32(name='Fail', example='0'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    restoreSchemaDetails?: {
      restoreSchemaDetail?: [ 
      {
        endTime?: string(name='EndTime', example='2020-11-05T06:45:18Z'),
        message?: string(name='Message', example='null'),
        startTime?: string(name='StartTime', example='2020-11-05T06:45:14Z'),
        state?: string(name='State', example='SUCCEEDED'),
        table?: string(name='Table', example='default:test1'),
      }
    ](name='RestoreSchemaDetail')
    }(name='RestoreSchemaDetails'),
    succeed?: int32(name='Succeed', example='1'),
    total?: long(name='Total', example='1'),
  }(name='RestoreSchema'),
  restoreSummary?: {
    endTime?: string(name='EndTime', example='2020-11-05T06:45:51Z'),
    recordId?: string(name='RecordId', example='20201105144514'),
    restoreToDate?: string(name='RestoreToDate', example='2020-11-04T05:15:00Z'),
    startTime?: string(name='StartTime', example='2020-11-05T06:45:14Z'),
    state?: string(name='State', example='SUCCEEDED'),
    targetCluster?: string(name='TargetCluster', example='ld-m5e2t34kr54wgxxxx'),
  }(name='RestoreSummary'),
  tables?: {
    table?: [ string ](name='Table')
  }(name='Tables'),
}

model DescribeRestoreTablesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRestoreTablesResponseBody(name='body'),
}

/**
 * @param request DescribeRestoreTablesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeRestoreTablesResponse
 */
async function describeRestoreTablesWithOptions(request: DescribeRestoreTablesRequest, runtime: Util.RuntimeOptions): DescribeRestoreTablesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.restoreRecordId)) {
    query['RestoreRecordId'] = request.restoreRecordId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRestoreTables',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeRestoreTablesRequest
 * @return DescribeRestoreTablesResponse
 */
async function describeRestoreTables(request: DescribeRestoreTablesRequest): DescribeRestoreTablesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRestoreTablesWithOptions(request, runtime);
}

model DescribeSecurityGroupsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp161ax8i03c4uq**'),
}

model DescribeSecurityGroupsResponseBody = {
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
  securityGroupIds?: {
    securityGroupId?: [ string ](name='SecurityGroupId')
  }(name='SecurityGroupIds'),
}

model DescribeSecurityGroupsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSecurityGroupsResponseBody(name='body'),
}

/**
 * @param request DescribeSecurityGroupsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeSecurityGroupsResponse
 */
async function describeSecurityGroupsWithOptions(request: DescribeSecurityGroupsRequest, runtime: Util.RuntimeOptions): DescribeSecurityGroupsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSecurityGroups',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeSecurityGroupsRequest
 * @return DescribeSecurityGroupsResponse
 */
async function describeSecurityGroups(request: DescribeSecurityGroupsRequest): DescribeSecurityGroupsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSecurityGroupsWithOptions(request, runtime);
}

model DescribeServerlessClusterRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16f1441y6p2****'),
  zoneId?: string(name='ZoneId', description='This parameter is required.', example='sdh0b7f4k5f****'),
}

model DescribeServerlessClusterResponseBody = {
  autoRenew?: string(name='AutoRenew', example='false'),
  clusterType?: string(name='ClusterType', example='single'),
  createTime?: string(name='CreateTime', example='2019-10-12T14:40:46'),
  cuSize?: string(name='CuSize', example='150'),
  diskSize?: string(name='DiskSize', example='200'),
  expireTime?: string(name='ExpireTime', example='2019-10-12T14:40:46'),
  haType?: string(name='HaType', example='false'),
  hasUser?: string(name='HasUser', example='false'),
  innerEndpoint?: string(name='InnerEndpoint', example='https://sh-wz91452kg946i****-lindorm-serverless-in.lindorm.rds.aliyuncs.com:443'),
  instanceId?: string(name='InstanceId', example='hb-bp16f1441y6p2****'),
  instanceName?: string(name='InstanceName', example='test'),
  isDeletionProtection?: string(name='IsDeletionProtection', example='true'),
  lockMode?: string(name='LockMode'),
  mainVersion?: string(name='MainVersion', example='2.0.8'),
  outerEndpoint?: string(name='OuterEndpoint', example='https://sh-wz91452kg946i****-lindorm-serverless.lindorm.rds.aliyuncs.com:443'),
  payType?: string(name='PayType', example='Postpaid'),
  regionId?: string(name='RegionId', example='cn-hangzhou'),
  requestId?: string(name='RequestId', example='89F81C30-320B-4550-91DB-C37C81D2358F'),
  reserverMaxQpsNum?: string(name='ReserverMaxQpsNum', example='100'),
  reserverMinQpsNum?: string(name='ReserverMinQpsNum', example='50'),
  resourceGroupId?: string(name='ResourceGroupId', example='rg-fjm2d4v7sf****'),
  status?: string(name='Status', example='ACTIVATION'),
  updateStatus?: string(name='UpdateStatus', example='NO'),
  vSwitchId?: string(name='VSwitchId', example='vsw-bp191ipotqf****'),
  vpcId?: string(name='VpcId', example='vpc-bp120k6ixs4eoghz****'),
  zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}

model DescribeServerlessClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeServerlessClusterResponseBody(name='body'),
}

/**
 * @param request DescribeServerlessClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeServerlessClusterResponse
 */
async function describeServerlessClusterWithOptions(request: DescribeServerlessClusterRequest, runtime: Util.RuntimeOptions): DescribeServerlessClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeServerlessCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeServerlessClusterRequest
 * @return DescribeServerlessClusterResponse
 */
async function describeServerlessCluster(request: DescribeServerlessClusterRequest): DescribeServerlessClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeServerlessClusterWithOptions(request, runtime);
}

model DescribeSubDomainRequest {
  regionId?: string(name='RegionId', example='cn-hangzhou'),
  zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}

model DescribeSubDomainResponseBody = {
  requestId?: string(name='RequestId', example='F4208C83-B9BC-4A64-A739-8F88E98DA469'),
  subDomain?: string(name='SubDomain', example='cn-hangzhou-h-aliyun'),
}

model DescribeSubDomainResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSubDomainResponseBody(name='body'),
}

/**
 * @param request DescribeSubDomainRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return DescribeSubDomainResponse
 */
async function describeSubDomainWithOptions(request: DescribeSubDomainRequest, runtime: Util.RuntimeOptions): DescribeSubDomainResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSubDomain',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request DescribeSubDomainRequest
 * @return DescribeSubDomainResponse
 */
async function describeSubDomain(request: DescribeSubDomainRequest): DescribeSubDomainResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSubDomainWithOptions(request, runtime);
}

model EnableHBaseueBackupRequest {
  clientToken?: string(name='ClientToken', example='xxx'),
  coldStorageSize?: int32(name='ColdStorageSize', example='800'),
  hbaseueClusterId?: string(name='HbaseueClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='2'),
}

model EnableHBaseueBackupResponseBody = {
  clusterId?: string(name='ClusterId', example='bds-m5e54q06ceyhxxxx'),
  orderId?: string(name='OrderId', example='1449xxx'),
  requestId?: string(name='RequestId', example='15272D5D-46E8-4400-9CC8-A7E7B589F575'),
}

model EnableHBaseueBackupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: EnableHBaseueBackupResponseBody(name='body'),
}

/**
 * @param request EnableHBaseueBackupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return EnableHBaseueBackupResponse
 */
async function enableHBaseueBackupWithOptions(request: EnableHBaseueBackupRequest, runtime: Util.RuntimeOptions): EnableHBaseueBackupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.coldStorageSize)) {
    query['ColdStorageSize'] = request.coldStorageSize;
  }
  if (!Util.isUnset(request.hbaseueClusterId)) {
    query['HbaseueClusterId'] = request.hbaseueClusterId;
  }
  if (!Util.isUnset(request.nodeCount)) {
    query['NodeCount'] = request.nodeCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'EnableHBaseueBackup',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request EnableHBaseueBackupRequest
 * @return EnableHBaseueBackupResponse
 */
async function enableHBaseueBackup(request: EnableHBaseueBackupRequest): EnableHBaseueBackupResponse {
  var runtime = new Util.RuntimeOptions{};
  return enableHBaseueBackupWithOptions(request, runtime);
}

model EnableHBaseueModuleRequest {
  autoRenewPeriod?: int32(name='AutoRenewPeriod', example='2'),
  bdsId?: string(name='BdsId', example='bds-bp174pm3tsk3****'),
  clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
  coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.large'),
  diskSize?: int32(name='DiskSize', example='400'),
  diskType?: string(name='DiskType', example='cloud_ssd'),
  hbaseueClusterId?: string(name='HbaseueClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
  moduleClusterName?: string(name='ModuleClusterName', example='cluster-name'),
  moduleTypeName?: string(name='ModuleTypeName', description='This parameter is required.', example='solr'),
  nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='2'),
  payType?: string(name='PayType', description='This parameter is required.', example='Prepaid'),
  period?: int32(name='Period', example='6'),
  periodUnit?: string(name='PeriodUnit', example='month'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-shenzhen'),
  vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-bp120k6ixs4eog*****'),
  vswitchId?: string(name='VswitchId', description='This parameter is required.', example='vsw-bp191ipotqj1ssyl*****'),
  zoneId?: string(name='ZoneId', description='This parameter is required.', example='cn-shenzhen-e'),
}

model EnableHBaseueModuleResponseBody = {
  clusterId?: string(name='ClusterId', example='ld-bp150tns0sjxs****-m1-ps'),
  orderId?: string(name='OrderId', example='21474915573****'),
  requestId?: string(name='RequestId', example='407075EA-47F5-5A2D-888F-C1F90B8F3FCA'),
}

model EnableHBaseueModuleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: EnableHBaseueModuleResponseBody(name='body'),
}

/**
 * @param request EnableHBaseueModuleRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return EnableHBaseueModuleResponse
 */
async function enableHBaseueModuleWithOptions(request: EnableHBaseueModuleRequest, runtime: Util.RuntimeOptions): EnableHBaseueModuleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.autoRenewPeriod)) {
    query['AutoRenewPeriod'] = request.autoRenewPeriod;
  }
  if (!Util.isUnset(request.bdsId)) {
    query['BdsId'] = request.bdsId;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.diskSize)) {
    query['DiskSize'] = request.diskSize;
  }
  if (!Util.isUnset(request.diskType)) {
    query['DiskType'] = request.diskType;
  }
  if (!Util.isUnset(request.hbaseueClusterId)) {
    query['HbaseueClusterId'] = request.hbaseueClusterId;
  }
  if (!Util.isUnset(request.masterInstanceType)) {
    query['MasterInstanceType'] = request.masterInstanceType;
  }
  if (!Util.isUnset(request.moduleClusterName)) {
    query['ModuleClusterName'] = request.moduleClusterName;
  }
  if (!Util.isUnset(request.moduleTypeName)) {
    query['ModuleTypeName'] = request.moduleTypeName;
  }
  if (!Util.isUnset(request.nodeCount)) {
    query['NodeCount'] = request.nodeCount;
  }
  if (!Util.isUnset(request.payType)) {
    query['PayType'] = request.payType;
  }
  if (!Util.isUnset(request.period)) {
    query['Period'] = request.period;
  }
  if (!Util.isUnset(request.periodUnit)) {
    query['PeriodUnit'] = request.periodUnit;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.vpcId)) {
    query['VpcId'] = request.vpcId;
  }
  if (!Util.isUnset(request.vswitchId)) {
    query['VswitchId'] = request.vswitchId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'EnableHBaseueModule',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request EnableHBaseueModuleRequest
 * @return EnableHBaseueModuleResponse
 */
async function enableHBaseueModule(request: EnableHBaseueModuleRequest): EnableHBaseueModuleResponse {
  var runtime = new Util.RuntimeOptions{};
  return enableHBaseueModuleWithOptions(request, runtime);
}

model EvaluateMultiZoneResourceRequest {
  arbiterVSwitchId?: string(name='ArbiterVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxb****'),
  arbiterZoneId?: string(name='ArbiterZoneId', description='This parameter is required.', example='cn-hangzhou-b'),
  archVersion?: string(name='ArchVersion', description='This parameter is required.', example='2.0'),
  autoRenewPeriod?: int32(name='AutoRenewPeriod', example='0'),
  clientToken?: string(name='ClientToken', example='f4g8t5rd2gr94****'),
  clusterName?: string(name='ClusterName', example='hbaseue_test'),
  coreDiskSize?: int32(name='CoreDiskSize', description='This parameter is required.', example='400'),
  coreDiskType?: string(name='CoreDiskType', description='This parameter is required.', example='cloud_ssd'),
  coreInstanceType?: string(name='CoreInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
  coreNodeCount?: int32(name='CoreNodeCount', description='This parameter is required.', example='4'),
  engine?: string(name='Engine', description='This parameter is required.', example='hbaseue'),
  engineVersion?: string(name='EngineVersion', description='This parameter is required.', example='2.0'),
  logDiskSize?: int32(name='LogDiskSize', example='400'),
  logDiskType?: string(name='LogDiskType', example='cloud_ssd'),
  logInstanceType?: string(name='LogInstanceType', example='hbase.sn1.medium'),
  logNodeCount?: int32(name='LogNodeCount', example='4'),
  masterInstanceType?: string(name='MasterInstanceType', description='This parameter is required.', example='hbase.sn1.medium'),
  multiZoneCombination?: string(name='MultiZoneCombination', description='This parameter is required.', example='cn-hangzhou-bef-aliyun-com'),
  payType?: string(name='PayType', description='This parameter is required.', example='Postpaid'),
  period?: int32(name='Period', example='1'),
  periodUnit?: string(name='PeriodUnit', example='month'),
  primaryVSwitchId?: string(name='PrimaryVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxe*****'),
  primaryZoneId?: string(name='PrimaryZoneId', description='This parameter is required.', example='cn-hangzhou-e'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  securityIPList?: string(name='SecurityIPList', example='127.0.0.1'),
  standbyVSwitchId?: string(name='StandbyVSwitchId', description='This parameter is required.', example='vsw-hangxzhouxf****'),
  standbyZoneId?: string(name='StandbyZoneId', description='This parameter is required.', example='cn-hangzhou-f'),
  vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-bp120k6ixs4eog*****'),
}

model EvaluateMultiZoneResourceResponseBody = {
  requestId?: string(name='RequestId', example='FB703B69-D4D4-4879-B9FE-6A37F67C46FD'),
  success?: boolean(name='Success', example='true'),
}

model EvaluateMultiZoneResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: EvaluateMultiZoneResourceResponseBody(name='body'),
}

/**
 * @param request EvaluateMultiZoneResourceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return EvaluateMultiZoneResourceResponse
 */
async function evaluateMultiZoneResourceWithOptions(request: EvaluateMultiZoneResourceRequest, runtime: Util.RuntimeOptions): EvaluateMultiZoneResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.arbiterVSwitchId)) {
    query['ArbiterVSwitchId'] = request.arbiterVSwitchId;
  }
  if (!Util.isUnset(request.arbiterZoneId)) {
    query['ArbiterZoneId'] = request.arbiterZoneId;
  }
  if (!Util.isUnset(request.archVersion)) {
    query['ArchVersion'] = request.archVersion;
  }
  if (!Util.isUnset(request.autoRenewPeriod)) {
    query['AutoRenewPeriod'] = request.autoRenewPeriod;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterName)) {
    query['ClusterName'] = request.clusterName;
  }
  if (!Util.isUnset(request.coreDiskSize)) {
    query['CoreDiskSize'] = request.coreDiskSize;
  }
  if (!Util.isUnset(request.coreDiskType)) {
    query['CoreDiskType'] = request.coreDiskType;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.coreNodeCount)) {
    query['CoreNodeCount'] = request.coreNodeCount;
  }
  if (!Util.isUnset(request.engine)) {
    query['Engine'] = request.engine;
  }
  if (!Util.isUnset(request.engineVersion)) {
    query['EngineVersion'] = request.engineVersion;
  }
  if (!Util.isUnset(request.logDiskSize)) {
    query['LogDiskSize'] = request.logDiskSize;
  }
  if (!Util.isUnset(request.logDiskType)) {
    query['LogDiskType'] = request.logDiskType;
  }
  if (!Util.isUnset(request.logInstanceType)) {
    query['LogInstanceType'] = request.logInstanceType;
  }
  if (!Util.isUnset(request.logNodeCount)) {
    query['LogNodeCount'] = request.logNodeCount;
  }
  if (!Util.isUnset(request.masterInstanceType)) {
    query['MasterInstanceType'] = request.masterInstanceType;
  }
  if (!Util.isUnset(request.multiZoneCombination)) {
    query['MultiZoneCombination'] = request.multiZoneCombination;
  }
  if (!Util.isUnset(request.payType)) {
    query['PayType'] = request.payType;
  }
  if (!Util.isUnset(request.period)) {
    query['Period'] = request.period;
  }
  if (!Util.isUnset(request.periodUnit)) {
    query['PeriodUnit'] = request.periodUnit;
  }
  if (!Util.isUnset(request.primaryVSwitchId)) {
    query['PrimaryVSwitchId'] = request.primaryVSwitchId;
  }
  if (!Util.isUnset(request.primaryZoneId)) {
    query['PrimaryZoneId'] = request.primaryZoneId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.securityIPList)) {
    query['SecurityIPList'] = request.securityIPList;
  }
  if (!Util.isUnset(request.standbyVSwitchId)) {
    query['StandbyVSwitchId'] = request.standbyVSwitchId;
  }
  if (!Util.isUnset(request.standbyZoneId)) {
    query['StandbyZoneId'] = request.standbyZoneId;
  }
  if (!Util.isUnset(request.vpcId)) {
    query['VpcId'] = request.vpcId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'EvaluateMultiZoneResource',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request EvaluateMultiZoneResourceRequest
 * @return EvaluateMultiZoneResourceResponse
 */
async function evaluateMultiZoneResource(request: EvaluateMultiZoneResourceRequest): EvaluateMultiZoneResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return evaluateMultiZoneResourceWithOptions(request, runtime);
}

model GetMultimodeCmsUrlRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
}

model GetMultimodeCmsUrlResponseBody = {
  clusterId?: string(name='ClusterId', example='hb-t4naqsay5gn******'),
  multimodCmsUrl?: string(name='MultimodCmsUrl', example='htpp://***********'),
  requestId?: string(name='RequestId', example='44183B05-852E-4716-B902-52977140190F'),
}

model GetMultimodeCmsUrlResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetMultimodeCmsUrlResponseBody(name='body'),
}

/**
 * @param request GetMultimodeCmsUrlRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetMultimodeCmsUrlResponse
 */
async function getMultimodeCmsUrlWithOptions(request: GetMultimodeCmsUrlRequest, runtime: Util.RuntimeOptions): GetMultimodeCmsUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetMultimodeCmsUrl',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request GetMultimodeCmsUrlRequest
 * @return GetMultimodeCmsUrlResponse
 */
async function getMultimodeCmsUrl(request: GetMultimodeCmsUrlRequest): GetMultimodeCmsUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMultimodeCmsUrlWithOptions(request, runtime);
}

model GrantRequest {
  accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
  aclActions?: string(name='AclActions', description='This parameter is required.', example='READ,WRITE'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  namespace?: string(name='Namespace', description='This parameter is required.', example='default'),
  tableName?: string(name='TableName', description='This parameter is required.', example='table'),
}

model GrantResponseBody = {
  requestId?: string(name='RequestId', example='9CBF8DF0-4931-4A54-9B60-4C6E1AB5****'),
}

model GrantResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GrantResponseBody(name='body'),
}

/**
 * @summary 授权账户权限
 *
 * @param request GrantRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GrantResponse
 */
async function grantWithOptions(request: GrantRequest, runtime: Util.RuntimeOptions): GrantResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.aclActions)) {
    query['AclActions'] = request.aclActions;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.namespace)) {
    query['Namespace'] = request.namespace;
  }
  if (!Util.isUnset(request.tableName)) {
    query['TableName'] = request.tableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'Grant',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 授权账户权限
 *
 * @param request GrantRequest
 * @return GrantResponse
 */
async function grant(request: GrantRequest): GrantResponse {
  var runtime = new Util.RuntimeOptions{};
  return grantWithOptions(request, runtime);
}

model ListHBaseInstancesRequest {
  vpcId?: string(name='VpcId', description='This parameter is required.', example='vpc-t4nx81tmlixcq5i****'),
}

model ListHBaseInstancesResponseBody = {
  instances?: {
    instance?: [ 
    {
      instanceId?: string(name='InstanceId', example='hb-t4naqsay5gn****'),
      instanceName?: string(name='InstanceName', example='name_test'),
      isDefault?: boolean(name='IsDefault', example='false'),
    }
  ](name='Instance')
  }(name='Instances'),
  requestId?: string(name='RequestId', example='89F81C30-320B-4550-91DB-C37C81D2358F'),
}

model ListHBaseInstancesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListHBaseInstancesResponseBody(name='body'),
}

/**
 * @param request ListHBaseInstancesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListHBaseInstancesResponse
 */
async function listHBaseInstancesWithOptions(request: ListHBaseInstancesRequest, runtime: Util.RuntimeOptions): ListHBaseInstancesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.vpcId)) {
    query['VpcId'] = request.vpcId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListHBaseInstances',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListHBaseInstancesRequest
 * @return ListHBaseInstancesResponse
 */
async function listHBaseInstances(request: ListHBaseInstancesRequest): ListHBaseInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listHBaseInstancesWithOptions(request, runtime);
}

model ListInstanceServiceConfigHistoriesRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
  pageNumber?: int32(name='PageNumber', example='10'),
  pageSize?: int32(name='PageSize', example='1'),
}

model ListInstanceServiceConfigHistoriesResponseBody = {
  configureHistoryList?: {
    config?: [ 
    {
      configureName?: string(name='ConfigureName', example='hbase#hbase-site.xml#hbase.client.keyvalue.maxsize'),
      createTime?: string(name='CreateTime', example='1608708923000'),
      effective?: string(name='Effective', example='false'),
      newValue?: string(name='NewValue', example='10485770'),
      oldValue?: string(name='OldValue', example='10485760'),
    }
  ](name='Config')
  }(name='ConfigureHistoryList'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageRecordCount?: int32(name='PageRecordCount', example='10'),
  requestId?: string(name='RequestId', example='658C1549-2C02-4FD9-9490-EB3B285F9DCA'),
  totalRecordCount?: long(name='TotalRecordCount', example='1'),
}

model ListInstanceServiceConfigHistoriesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListInstanceServiceConfigHistoriesResponseBody(name='body'),
}

/**
 * @param request ListInstanceServiceConfigHistoriesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListInstanceServiceConfigHistoriesResponse
 */
async function listInstanceServiceConfigHistoriesWithOptions(request: ListInstanceServiceConfigHistoriesRequest, runtime: Util.RuntimeOptions): ListInstanceServiceConfigHistoriesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListInstanceServiceConfigHistories',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListInstanceServiceConfigHistoriesRequest
 * @return ListInstanceServiceConfigHistoriesResponse
 */
async function listInstanceServiceConfigHistories(request: ListInstanceServiceConfigHistoriesRequest): ListInstanceServiceConfigHistoriesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listInstanceServiceConfigHistoriesWithOptions(request, runtime);
}

model ListInstanceServiceConfigurationsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  pageNumber?: int32(name='PageNumber', example='10'),
  pageSize?: int32(name='PageSize', example='1'),
}

model ListInstanceServiceConfigurationsResponseBody = {
  configureList?: {
    config?: [ 
    {
      configureName?: string(name='ConfigureName', example='hbase#hbase-site.xml#hbase.client.keyvalue.maxsize'),
      configureUnit?: string(name='ConfigureUnit', example='INT'),
      defaultValue?: string(name='DefaultValue', example='10485760'),
      description?: string(name='Description', example='hbase client keyvalue maxsize'),
      needRestart?: string(name='NeedRestart', example='true'),
      runningValue?: string(name='RunningValue', example='10485760'),
      valueRange?: string(name='ValueRange', example='R[10485760,52428800]'),
    }
  ](name='Config')
  }(name='ConfigureList'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageRecordCount?: int32(name='PageRecordCount', example='10'),
  requestId?: string(name='RequestId', example='5B381E36-BCA3-4377-8638-B65C236617D5'),
  totalRecordCount?: long(name='TotalRecordCount', example='42'),
}

model ListInstanceServiceConfigurationsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListInstanceServiceConfigurationsResponseBody(name='body'),
}

/**
 * @param request ListInstanceServiceConfigurationsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListInstanceServiceConfigurationsResponse
 */
async function listInstanceServiceConfigurationsWithOptions(request: ListInstanceServiceConfigurationsRequest, runtime: Util.RuntimeOptions): ListInstanceServiceConfigurationsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListInstanceServiceConfigurations',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListInstanceServiceConfigurationsRequest
 * @return ListInstanceServiceConfigurationsResponse
 */
async function listInstanceServiceConfigurations(request: ListInstanceServiceConfigurationsRequest): ListInstanceServiceConfigurationsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listInstanceServiceConfigurationsWithOptions(request, runtime);
}

model ListTagResourcesRequest {
  nextToken?: string(name='NextToken', example='NextToken'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  resourceId?: [ string ](name='ResourceId', example='bds-bp15e022622f****'),
  tag?: [ 
    {
      key?: string(name='Key', example='key1'),
      value?: string(name='Value', example='value1'),
    }
  ](name='Tag'),
}

model ListTagResourcesResponseBody = {
  nextToken?: string(name='NextToken', example='1d2db86sca4384811e0b5e8707e68****'),
  requestId?: string(name='RequestId', example='74F02441-9A8D-48F6-933F-E317AEB28DBF'),
  tagResources?: {
    tagResource?: [ 
    {
      resourceId?: string(name='ResourceId', example='bds-bp15e022622f****'),
      resourceType?: string(name='ResourceType', example='ALIYUN::MULTIMOD::CLUSTER'),
      tagKey?: string(name='TagKey', example='k1'),
      tagValue?: string(name='TagValue', example='v2'),
    }
  ](name='TagResource')
  }(name='TagResources'),
}

model ListTagResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListTagResourcesResponseBody(name='body'),
}

/**
 * @param request ListTagResourcesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListTagResourcesResponse
 */
async function listTagResourcesWithOptions(request: ListTagResourcesRequest, runtime: Util.RuntimeOptions): ListTagResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.nextToken)) {
    query['NextToken'] = request.nextToken;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceId)) {
    query['ResourceId'] = request.resourceId;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListTagResources',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListTagResourcesRequest
 * @return ListTagResourcesResponse
 */
async function listTagResources(request: ListTagResourcesRequest): ListTagResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listTagResourcesWithOptions(request, runtime);
}

model ListTagsRequest {
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-shanghai'),
}

model ListTagsResponseBody = {
  requestId?: string(name='RequestId', example='36D1BE9B-3C4A-425B-947A-69E3D77999C4'),
  tags?: {
    tag?: [ 
    {
      tagKey?: string(name='TagKey', example='k1'),
      tagValue?: string(name='TagValue', example='v2'),
    }
  ](name='Tag')
  }(name='Tags'),
}

model ListTagsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListTagsResponseBody(name='body'),
}

/**
 * @param request ListTagsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListTagsResponse
 */
async function listTagsWithOptions(request: ListTagsRequest, runtime: Util.RuntimeOptions): ListTagsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListTags',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ListTagsRequest
 * @return ListTagsResponse
 */
async function listTags(request: ListTagsRequest): ListTagsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listTagsWithOptions(request, runtime);
}

model ModifyAccountPasswordRequest {
  accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  newAccountPassword?: string(name='NewAccountPassword', description='This parameter is required.', example='**********'),
}

model ModifyAccountPasswordResponseBody = {
  requestId?: string(name='RequestId', example='AFAA617B-3268-5883-982B-DB8EC8CC1F1B'),
}

model ModifyAccountPasswordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyAccountPasswordResponseBody(name='body'),
}

/**
 * @summary 更改账户密码
 *
 * @param request ModifyAccountPasswordRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyAccountPasswordResponse
 */
async function modifyAccountPasswordWithOptions(request: ModifyAccountPasswordRequest, runtime: Util.RuntimeOptions): ModifyAccountPasswordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.newAccountPassword)) {
    query['NewAccountPassword'] = request.newAccountPassword;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyAccountPassword',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 更改账户密码
 *
 * @param request ModifyAccountPasswordRequest
 * @return ModifyAccountPasswordResponse
 */
async function modifyAccountPassword(request: ModifyAccountPasswordRequest): ModifyAccountPasswordResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyAccountPasswordWithOptions(request, runtime);
}

model ModifyActiveOperationTasksRequest {
  ids?: string(name='Ids', description='This parameter is required.', example='1111,2222'),
  immediateStart?: int32(name='ImmediateStart', example='1'),
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  securityToken?: string(name='SecurityToken'),
  switchTime?: string(name='SwitchTime', description='This parameter is required.', example='2022-02-17T18:50:00Z'),
}

model ModifyActiveOperationTasksResponseBody = {
  ids?: string(name='Ids', example='1111,2222'),
  requestId?: string(name='RequestId', example='8C9CC46A-9532-4752-B59F-580112C5A45B'),
}

model ModifyActiveOperationTasksResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyActiveOperationTasksResponseBody(name='body'),
}

/**
 * @param request ModifyActiveOperationTasksRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyActiveOperationTasksResponse
 */
async function modifyActiveOperationTasksWithOptions(request: ModifyActiveOperationTasksRequest, runtime: Util.RuntimeOptions): ModifyActiveOperationTasksResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.immediateStart)) {
    query['ImmediateStart'] = request.immediateStart;
  }
  if (!Util.isUnset(request.ownerAccount)) {
    query['OwnerAccount'] = request.ownerAccount;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.securityToken)) {
    query['SecurityToken'] = request.securityToken;
  }
  if (!Util.isUnset(request.switchTime)) {
    query['SwitchTime'] = request.switchTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyActiveOperationTasks',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyActiveOperationTasksRequest
 * @return ModifyActiveOperationTasksResponse
 */
async function modifyActiveOperationTasks(request: ModifyActiveOperationTasksRequest): ModifyActiveOperationTasksResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyActiveOperationTasksWithOptions(request, runtime);
}

model ModifyBackupPlanConfigRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  fullBackupCycle?: string(name='FullBackupCycle', description='This parameter is required.', example='7'),
  minHFileBackupCount?: string(name='MinHFileBackupCount', description='This parameter is required.', example='3'),
  nextFullBackupDate?: string(name='NextFullBackupDate', description='This parameter is required.', example='2020-11-09T18:00:00Z'),
  tables?: string(name='Tables', description='This parameter is required.', example='*'),
}

model ModifyBackupPlanConfigResponseBody = {
  requestId?: string(name='RequestId', example='50F4A8C2-076F-4703-9813-2FCD7FBB91C2'),
}

model ModifyBackupPlanConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyBackupPlanConfigResponseBody(name='body'),
}

/**
 * @param request ModifyBackupPlanConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyBackupPlanConfigResponse
 */
async function modifyBackupPlanConfigWithOptions(request: ModifyBackupPlanConfigRequest, runtime: Util.RuntimeOptions): ModifyBackupPlanConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.fullBackupCycle)) {
    query['FullBackupCycle'] = request.fullBackupCycle;
  }
  if (!Util.isUnset(request.minHFileBackupCount)) {
    query['MinHFileBackupCount'] = request.minHFileBackupCount;
  }
  if (!Util.isUnset(request.nextFullBackupDate)) {
    query['NextFullBackupDate'] = request.nextFullBackupDate;
  }
  if (!Util.isUnset(request.tables)) {
    query['Tables'] = request.tables;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyBackupPlanConfig',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyBackupPlanConfigRequest
 * @return ModifyBackupPlanConfigResponse
 */
async function modifyBackupPlanConfig(request: ModifyBackupPlanConfigRequest): ModifyBackupPlanConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyBackupPlanConfigWithOptions(request, runtime);
}

model ModifyBackupPolicyRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  preferredBackupEndTimeUTC?: string(name='PreferredBackupEndTimeUTC', example='18:00Z'),
  preferredBackupPeriod?: string(name='PreferredBackupPeriod', description='This parameter is required.', example='Thursday'),
  preferredBackupStartTimeUTC?: string(name='PreferredBackupStartTimeUTC', example='17:00Z'),
  preferredBackupTime?: string(name='PreferredBackupTime', description='This parameter is required.', example='01:00-02:00'),
}

model ModifyBackupPolicyResponseBody = {
  requestId?: string(name='RequestId', example='17E3AC63-300D-4B69-9108-45EC20E50E85'),
}

model ModifyBackupPolicyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyBackupPolicyResponseBody(name='body'),
}

/**
 * @param request ModifyBackupPolicyRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyBackupPolicyResponse
 */
async function modifyBackupPolicyWithOptions(request: ModifyBackupPolicyRequest, runtime: Util.RuntimeOptions): ModifyBackupPolicyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.preferredBackupEndTimeUTC)) {
    query['PreferredBackupEndTimeUTC'] = request.preferredBackupEndTimeUTC;
  }
  if (!Util.isUnset(request.preferredBackupPeriod)) {
    query['PreferredBackupPeriod'] = request.preferredBackupPeriod;
  }
  if (!Util.isUnset(request.preferredBackupStartTimeUTC)) {
    query['PreferredBackupStartTimeUTC'] = request.preferredBackupStartTimeUTC;
  }
  if (!Util.isUnset(request.preferredBackupTime)) {
    query['PreferredBackupTime'] = request.preferredBackupTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyBackupPolicy',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyBackupPolicyRequest
 * @return ModifyBackupPolicyResponse
 */
async function modifyBackupPolicy(request: ModifyBackupPolicyRequest): ModifyBackupPolicyResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyBackupPolicyWithOptions(request, runtime);
}

model ModifyClusterDeletionProtectionRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-****************'),
  protection?: boolean(name='Protection', description='This parameter is required.', example='true'),
}

model ModifyClusterDeletionProtectionResponseBody = {
  requestId?: string(name='RequestId', example='24C80BD8-C710-4138-893A-D2AFED4FC13D'),
}

model ModifyClusterDeletionProtectionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyClusterDeletionProtectionResponseBody(name='body'),
}

/**
 * @param request ModifyClusterDeletionProtectionRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyClusterDeletionProtectionResponse
 */
async function modifyClusterDeletionProtectionWithOptions(request: ModifyClusterDeletionProtectionRequest, runtime: Util.RuntimeOptions): ModifyClusterDeletionProtectionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.protection)) {
    query['Protection'] = request.protection;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyClusterDeletionProtection',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyClusterDeletionProtectionRequest
 * @return ModifyClusterDeletionProtectionResponse
 */
async function modifyClusterDeletionProtection(request: ModifyClusterDeletionProtectionRequest): ModifyClusterDeletionProtectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyClusterDeletionProtectionWithOptions(request, runtime);
}

model ModifyDiskWarningLineRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-m5eznlga4k5bcxxxx'),
  warningLine?: int32(name='WarningLine', description='This parameter is required.', example='80'),
}

model ModifyDiskWarningLineResponseBody = {
  requestId?: string(name='RequestId', example='FC4A930D-3AEE-4C9D-BC70-C0F2EEEAA174'),
}

model ModifyDiskWarningLineResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyDiskWarningLineResponseBody(name='body'),
}

/**
 * @param request ModifyDiskWarningLineRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyDiskWarningLineResponse
 */
async function modifyDiskWarningLineWithOptions(request: ModifyDiskWarningLineRequest, runtime: Util.RuntimeOptions): ModifyDiskWarningLineResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.warningLine)) {
    query['WarningLine'] = request.warningLine;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyDiskWarningLine',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyDiskWarningLineRequest
 * @return ModifyDiskWarningLineResponse
 */
async function modifyDiskWarningLine(request: ModifyDiskWarningLineRequest): ModifyDiskWarningLineResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyDiskWarningLineWithOptions(request, runtime);
}

model ModifyInstanceMaintainTimeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1b**6jco89****'),
  maintainEndTime?: string(name='MaintainEndTime', description='This parameter is required.', example='06:00Z'),
  maintainStartTime?: string(name='MaintainStartTime', description='This parameter is required.', example='02:00Z'),
}

model ModifyInstanceMaintainTimeResponseBody = {
  requestId?: string(name='RequestId', example='C9085433-A56A-4089-B49A-DF5A4E2B7B06'),
}

model ModifyInstanceMaintainTimeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyInstanceMaintainTimeResponseBody(name='body'),
}

/**
 * @param request ModifyInstanceMaintainTimeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyInstanceMaintainTimeResponse
 */
async function modifyInstanceMaintainTimeWithOptions(request: ModifyInstanceMaintainTimeRequest, runtime: Util.RuntimeOptions): ModifyInstanceMaintainTimeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.maintainEndTime)) {
    query['MaintainEndTime'] = request.maintainEndTime;
  }
  if (!Util.isUnset(request.maintainStartTime)) {
    query['MaintainStartTime'] = request.maintainStartTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyInstanceMaintainTime',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyInstanceMaintainTimeRequest
 * @return ModifyInstanceMaintainTimeResponse
 */
async function modifyInstanceMaintainTime(request: ModifyInstanceMaintainTimeRequest): ModifyInstanceMaintainTimeResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyInstanceMaintainTimeWithOptions(request, runtime);
}

model ModifyInstanceNameRequest {
  clientToken?: string(name='ClientToken', example='ETnLKlblzczshOTUbOCz****'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  clusterName?: string(name='ClusterName', description='This parameter is required.', example='testhbaseone'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}

model ModifyInstanceNameResponseBody = {
  requestId?: string(name='RequestId', example='959DA199-54E5-569D-AD46-92BED8515E62'),
}

model ModifyInstanceNameResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyInstanceNameResponseBody(name='body'),
}

/**
 * @param request ModifyInstanceNameRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyInstanceNameResponse
 */
async function modifyInstanceNameWithOptions(request: ModifyInstanceNameRequest, runtime: Util.RuntimeOptions): ModifyInstanceNameResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.clusterName)) {
    query['ClusterName'] = request.clusterName;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyInstanceName',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyInstanceNameRequest
 * @return ModifyInstanceNameResponse
 */
async function modifyInstanceName(request: ModifyInstanceNameRequest): ModifyInstanceNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyInstanceNameWithOptions(request, runtime);
}

model ModifyInstanceServiceConfigRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  configureName?: string(name='ConfigureName', description='This parameter is required.', example='hbase#hbase-site.xml#hbase.client.keyvalue.maxsize'),
  configureValue?: string(name='ConfigureValue', description='This parameter is required.', example='10485770'),
  parameters?: string(name='Parameters', example='{"key1=value1", "key2=value2"}'),
  restart?: boolean(name='Restart', example='false'),
}

model ModifyInstanceServiceConfigResponseBody = {
  requestId?: string(name='RequestId', example='F008B7AB-025D-4C20-AE12-047C8F8C3D97'),
}

model ModifyInstanceServiceConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyInstanceServiceConfigResponseBody(name='body'),
}

/**
 * @param request ModifyInstanceServiceConfigRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyInstanceServiceConfigResponse
 */
async function modifyInstanceServiceConfigWithOptions(request: ModifyInstanceServiceConfigRequest, runtime: Util.RuntimeOptions): ModifyInstanceServiceConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.configureName)) {
    query['ConfigureName'] = request.configureName;
  }
  if (!Util.isUnset(request.configureValue)) {
    query['ConfigureValue'] = request.configureValue;
  }
  if (!Util.isUnset(request.parameters)) {
    query['Parameters'] = request.parameters;
  }
  if (!Util.isUnset(request.restart)) {
    query['Restart'] = request.restart;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyInstanceServiceConfig',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyInstanceServiceConfigRequest
 * @return ModifyInstanceServiceConfigResponse
 */
async function modifyInstanceServiceConfig(request: ModifyInstanceServiceConfigRequest): ModifyInstanceServiceConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyInstanceServiceConfigWithOptions(request, runtime);
}

model ModifyInstanceTypeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1x940uh********'),
  coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.8xlarge'),
  masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.large'),
}

model ModifyInstanceTypeResponseBody = {
  orderId?: string(name='OrderId', example='123412341234123'),
  requestId?: string(name='RequestId', example='3E19E345-101D-4014-946C-****'),
}

model ModifyInstanceTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyInstanceTypeResponseBody(name='body'),
}

/**
 * @param request ModifyInstanceTypeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyInstanceTypeResponse
 */
async function modifyInstanceTypeWithOptions(request: ModifyInstanceTypeRequest, runtime: Util.RuntimeOptions): ModifyInstanceTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.masterInstanceType)) {
    query['MasterInstanceType'] = request.masterInstanceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyInstanceType',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyInstanceTypeRequest
 * @return ModifyInstanceTypeResponse
 */
async function modifyInstanceType(request: ModifyInstanceTypeRequest): ModifyInstanceTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyInstanceTypeWithOptions(request, runtime);
}

model ModifyIpWhitelistRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp1uoihlf82e8****'),
  groupName?: string(name='GroupName', description='This parameter is required.', example='group_01'),
  ipList?: string(name='IpList', example='42.120.XX.XX'),
  ipVersion?: string(name='IpVersion', description='This parameter is required.', example='4'),
}

model ModifyIpWhitelistResponseBody = {
  requestId?: string(name='RequestId', example='101CFA8A-FB88-5014-A10C-3A0DA9AD8B0B'),
}

model ModifyIpWhitelistResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyIpWhitelistResponseBody(name='body'),
}

/**
 * @param request ModifyIpWhitelistRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyIpWhitelistResponse
 */
async function modifyIpWhitelistWithOptions(request: ModifyIpWhitelistRequest, runtime: Util.RuntimeOptions): ModifyIpWhitelistResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.groupName)) {
    query['GroupName'] = request.groupName;
  }
  if (!Util.isUnset(request.ipList)) {
    query['IpList'] = request.ipList;
  }
  if (!Util.isUnset(request.ipVersion)) {
    query['IpVersion'] = request.ipVersion;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyIpWhitelist',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyIpWhitelistRequest
 * @return ModifyIpWhitelistResponse
 */
async function modifyIpWhitelist(request: ModifyIpWhitelistRequest): ModifyIpWhitelistResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyIpWhitelistWithOptions(request, runtime);
}

model ModifyMultiZoneClusterNodeTypeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-dj45g7d6rbrd****'),
  coreInstanceType?: string(name='CoreInstanceType', example='hbase.sn1.large'),
  logInstanceType?: string(name='LogInstanceType', example='hbase.sn1.2xlarge'),
  masterInstanceType?: string(name='MasterInstanceType', example='hbase.sn1.8xlarge'),
}

model ModifyMultiZoneClusterNodeTypeResponseBody = {
  orderId?: string(name='OrderId', example='12341234123****'),
  requestId?: string(name='RequestId', example='06CF7A6F-A81C-431D-BACD-793F24A67C54'),
}

model ModifyMultiZoneClusterNodeTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyMultiZoneClusterNodeTypeResponseBody(name='body'),
}

/**
 * @param request ModifyMultiZoneClusterNodeTypeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyMultiZoneClusterNodeTypeResponse
 */
async function modifyMultiZoneClusterNodeTypeWithOptions(request: ModifyMultiZoneClusterNodeTypeRequest, runtime: Util.RuntimeOptions): ModifyMultiZoneClusterNodeTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.coreInstanceType)) {
    query['CoreInstanceType'] = request.coreInstanceType;
  }
  if (!Util.isUnset(request.logInstanceType)) {
    query['LogInstanceType'] = request.logInstanceType;
  }
  if (!Util.isUnset(request.masterInstanceType)) {
    query['MasterInstanceType'] = request.masterInstanceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyMultiZoneClusterNodeType',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyMultiZoneClusterNodeTypeRequest
 * @return ModifyMultiZoneClusterNodeTypeResponse
 */
async function modifyMultiZoneClusterNodeType(request: ModifyMultiZoneClusterNodeTypeRequest): ModifyMultiZoneClusterNodeTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyMultiZoneClusterNodeTypeWithOptions(request, runtime);
}

model ModifySecurityGroupsRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16f1441y6p2kv**'),
  securityGroupIds?: string(name='SecurityGroupIds', description='This parameter is required.', example='sg-t4ng4yyc916o81nu****,sg-x4gg4dyc9d6w********'),
}

model ModifySecurityGroupsResponseBody = {
  requestId?: string(name='RequestId', example='F4AD2E65-482B-46B6-942E-765989B1C8A3'),
}

model ModifySecurityGroupsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifySecurityGroupsResponseBody(name='body'),
}

/**
 * @param request ModifySecurityGroupsRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifySecurityGroupsResponse
 */
async function modifySecurityGroupsWithOptions(request: ModifySecurityGroupsRequest, runtime: Util.RuntimeOptions): ModifySecurityGroupsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.securityGroupIds)) {
    query['SecurityGroupIds'] = request.securityGroupIds;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifySecurityGroups',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifySecurityGroupsRequest
 * @return ModifySecurityGroupsResponse
 */
async function modifySecurityGroups(request: ModifySecurityGroupsRequest): ModifySecurityGroupsResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifySecurityGroupsWithOptions(request, runtime);
}

model ModifyUIAccountPasswordRequest {
  accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
  accountPassword?: string(name='AccountPassword', description='This parameter is required.', example='**********'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
}

model ModifyUIAccountPasswordResponseBody = {
  requestId?: string(name='RequestId', example='BED4ADEB-4EA9-507E-892C-84112D6AC7C1'),
}

model ModifyUIAccountPasswordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ModifyUIAccountPasswordResponseBody(name='body'),
}

/**
 * @param request ModifyUIAccountPasswordRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ModifyUIAccountPasswordResponse
 */
async function modifyUIAccountPasswordWithOptions(request: ModifyUIAccountPasswordRequest, runtime: Util.RuntimeOptions): ModifyUIAccountPasswordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.accountPassword)) {
    query['AccountPassword'] = request.accountPassword;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ModifyUIAccountPassword',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ModifyUIAccountPasswordRequest
 * @return ModifyUIAccountPasswordResponse
 */
async function modifyUIAccountPassword(request: ModifyUIAccountPasswordRequest): ModifyUIAccountPasswordResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyUIAccountPasswordWithOptions(request, runtime);
}

model MoveResourceGroupRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
  newResourceGroupId?: string(name='NewResourceGroupId', description='This parameter is required.', example='rg-aekzrk6zzsy****'),
}

model MoveResourceGroupResponseBody = {
  requestId?: string(name='RequestId', example='8CD9BFBC-D575-5FCC-BA7E-956BF0D0****'),
}

model MoveResourceGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: MoveResourceGroupResponseBody(name='body'),
}

/**
 * @param request MoveResourceGroupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return MoveResourceGroupResponse
 */
async function moveResourceGroupWithOptions(request: MoveResourceGroupRequest, runtime: Util.RuntimeOptions): MoveResourceGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.newResourceGroupId)) {
    query['NewResourceGroupId'] = request.newResourceGroupId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MoveResourceGroup',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request MoveResourceGroupRequest
 * @return MoveResourceGroupResponse
 */
async function moveResourceGroup(request: MoveResourceGroupRequest): MoveResourceGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return moveResourceGroupWithOptions(request, runtime);
}

model OpenBackupRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}

model OpenBackupResponseBody = {
  requestId?: string(name='RequestId', example='C977DF60-7D06-4E34-A27D-8BC696C5112A'),
}

model OpenBackupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: OpenBackupResponseBody(name='body'),
}

/**
 * @param request OpenBackupRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return OpenBackupResponse
 */
async function openBackupWithOptions(request: OpenBackupRequest, runtime: Util.RuntimeOptions): OpenBackupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OpenBackup',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request OpenBackupRequest
 * @return OpenBackupResponse
 */
async function openBackup(request: OpenBackupRequest): OpenBackupResponse {
  var runtime = new Util.RuntimeOptions{};
  return openBackupWithOptions(request, runtime);
}

model PurgeInstanceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-m5ek15uzs7613xxxx'),
}

model PurgeInstanceResponseBody = {
  requestId?: string(name='RequestId', example='276F899F-E952-496F-81B8-BD46D86854E3'),
}

model PurgeInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PurgeInstanceResponseBody(name='body'),
}

/**
 * @param request PurgeInstanceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return PurgeInstanceResponse
 */
async function purgeInstanceWithOptions(request: PurgeInstanceRequest, runtime: Util.RuntimeOptions): PurgeInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PurgeInstance',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request PurgeInstanceRequest
 * @return PurgeInstanceResponse
 */
async function purgeInstance(request: PurgeInstanceRequest): PurgeInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return purgeInstanceWithOptions(request, runtime);
}

model QueryHBaseHaDBRequest {
  bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23ia4k'),
}

model QueryHBaseHaDBResponseBody = {
  clusterList?: {
    cluster?: [ 
    {
      activeName?: string(name='ActiveName', example='hb-t4nn7dy1u1etbzmzm'),
      bdsName?: string(name='BdsName', description='bdsId', example='bds-t4n3496whj23ia4k'),
      haName?: string(name='HaName', example='ha-v21tmnxjwh2yuy1il'),
      haSlbConnList?: {
        haSlbConn?: [ 
        {
          hbaseType?: string(name='HbaseType', example='Standby'),
          slbConnAddr?: string(name='SlbConnAddr', example='ha-v21tmnxjwh2yuy1il-phoenix.bds.9b78df04-b.rds.aliyuncs.com:8765'),
          slbType?: string(name='SlbType', example='phoenix'),
        }
      ](name='HaSlbConn')
      }(name='HaSlbConnList'),
      standbyName?: string(name='StandbyName', example='hb-t4n0ye37832tx22vz'),
    }
  ](name='Cluster')
  }(name='ClusterList'),
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  requestId?: string(name='RequestId', example='963355AD-A3B1-4654-AFFC-B5186EB8F889'),
  totalCount?: long(name='TotalCount', example='1'),
}

model QueryHBaseHaDBResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: QueryHBaseHaDBResponseBody(name='body'),
}

/**
 * @param request QueryHBaseHaDBRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return QueryHBaseHaDBResponse
 */
async function queryHBaseHaDBWithOptions(request: QueryHBaseHaDBRequest, runtime: Util.RuntimeOptions): QueryHBaseHaDBResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bdsId)) {
    query['BdsId'] = request.bdsId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryHBaseHaDB',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request QueryHBaseHaDBRequest
 * @return QueryHBaseHaDBResponse
 */
async function queryHBaseHaDB(request: QueryHBaseHaDBRequest): QueryHBaseHaDBResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryHBaseHaDBWithOptions(request, runtime);
}

model QueryXpackRelateDBRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ap-bp1qtz9rcbbt3p6ng'),
  hasSingleNode?: boolean(name='HasSingleNode', example='false'),
  relateDbType?: string(name='RelateDbType', description='This parameter is required.', example='hbase'),
}

model QueryXpackRelateDBResponseBody = {
  clusterList?: {
    cluster?: [ 
    {
      clusterId?: string(name='ClusterId', example='hb-bp16o0pd52e3y582s'),
      clusterName?: string(name='ClusterName', example='hbase_test'),
      DBType?: string(name='DBType', example='hbase'),
      DBVersion?: string(name='DBVersion', example='2.0'),
      isRelated?: boolean(name='IsRelated', example='false'),
      lockMode?: string(name='LockMode', example='..'),
      status?: string(name='Status', example='ACTIVATION'),
    }
  ](name='Cluster')
  }(name='ClusterList'),
  requestId?: string(name='RequestId', example='288E9010-36DD-499C-B4DA-61E4362DA4CC'),
}

model QueryXpackRelateDBResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: QueryXpackRelateDBResponseBody(name='body'),
}

/**
 * @param request QueryXpackRelateDBRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return QueryXpackRelateDBResponse
 */
async function queryXpackRelateDBWithOptions(request: QueryXpackRelateDBRequest, runtime: Util.RuntimeOptions): QueryXpackRelateDBResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.hasSingleNode)) {
    query['HasSingleNode'] = request.hasSingleNode;
  }
  if (!Util.isUnset(request.relateDbType)) {
    query['RelateDbType'] = request.relateDbType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryXpackRelateDB',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request QueryXpackRelateDBRequest
 * @return QueryXpackRelateDBResponse
 */
async function queryXpackRelateDB(request: QueryXpackRelateDBRequest): QueryXpackRelateDBResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryXpackRelateDBWithOptions(request, runtime);
}

model RelateDbForHBaseHaRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='bds-t4nj9v2x85******'),
  haActive?: string(name='HaActive', description='This parameter is required.', example='hb-bp1w6krp539******'),
  haActiveClusterKey?: string(name='HaActiveClusterKey', example='hb-t4naqsay5gn******-master1-001.hbase.singapore.rds.aliyuncs.com,hb-t4naqsay5gn******-master3-001.hbase.singapore.rds.aliyuncs.com,hb-t4naqsay5gn******-master2-001.hbase.singapore.rds.aliyuncs.com:2181:/hbase'),
  haActiveDBType?: string(name='HaActiveDBType', description='This parameter is required.', example='hbase'),
  haActiveHbaseFsDir?: string(name='HaActiveHbaseFsDir', example='/hbase'),
  haActiveHdfsUri?: string(name='HaActiveHdfsUri', example='hdfs://hb-t4naqsay5gn******-master1-001.hbase.rds.aliyuncs.com:8020,hb-t4naqsay5gn******-master2-001.hbase.rds.aliyuncs.com:8020'),
  haActivePassword?: string(name='HaActivePassword', example='root'),
  haActiveUser?: string(name='HaActiveUser', example='root'),
  haActiveVersion?: string(name='HaActiveVersion', example='HBase2x'),
  haMigrateType?: string(name='HaMigrateType', description='This parameter is required.', example='CLUSTER'),
  haStandby?: string(name='HaStandby', description='This parameter is required.', example='hb-bp1bl7iqzka******'),
  haStandbyClusterKey?: string(name='HaStandbyClusterKey', example='hb-bp1w6krp539******-master1-001.hbase.singapore.rds.aliyuncs.com,hb-bp1w6krp539******-master3-001.hbase.singapore.rds.aliyuncs.com,hb-t4naqsay5gn******-master2-001.hbase.singapore.rds.aliyuncs.com:2181:/hbase'),
  haStandbyDBType?: string(name='HaStandbyDBType', description='This parameter is required.', example='hbase'),
  haStandbyHbaseFsDir?: string(name='HaStandbyHbaseFsDir', example='/hbase'),
  haStandbyHdfsUri?: string(name='HaStandbyHdfsUri', example='hdfs://hb-bp1w6krp539******-master1-001.hbase.rds.aliyuncs.com:8020,hb-bp1w6krp539******-master2-001.hbase.rds.aliyuncs.com:8020'),
  haStandbyPassword?: string(name='HaStandbyPassword', example='root'),
  haStandbyUser?: string(name='HaStandbyUser', example='root'),
  haStandbyVersion?: string(name='HaStandbyVersion', example='HBase2x'),
  haTables?: string(name='HaTables', example='test,test1'),
  isActiveStandard?: boolean(name='IsActiveStandard', description='This parameter is required.', example='true'),
  isStandbyStandard?: boolean(name='IsStandbyStandard', description='This parameter is required.', example='true'),
}

model RelateDbForHBaseHaResponseBody = {
  requestId?: string(name='RequestId', example='DC654531-0799-4502-AFA5-80EE1C16829A'),
}

model RelateDbForHBaseHaResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RelateDbForHBaseHaResponseBody(name='body'),
}

/**
 * @param request RelateDbForHBaseHaRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RelateDbForHBaseHaResponse
 */
async function relateDbForHBaseHaWithOptions(request: RelateDbForHBaseHaRequest, runtime: Util.RuntimeOptions): RelateDbForHBaseHaResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.haActive)) {
    query['HaActive'] = request.haActive;
  }
  if (!Util.isUnset(request.haActiveClusterKey)) {
    query['HaActiveClusterKey'] = request.haActiveClusterKey;
  }
  if (!Util.isUnset(request.haActiveDBType)) {
    query['HaActiveDBType'] = request.haActiveDBType;
  }
  if (!Util.isUnset(request.haActiveHbaseFsDir)) {
    query['HaActiveHbaseFsDir'] = request.haActiveHbaseFsDir;
  }
  if (!Util.isUnset(request.haActiveHdfsUri)) {
    query['HaActiveHdfsUri'] = request.haActiveHdfsUri;
  }
  if (!Util.isUnset(request.haActivePassword)) {
    query['HaActivePassword'] = request.haActivePassword;
  }
  if (!Util.isUnset(request.haActiveUser)) {
    query['HaActiveUser'] = request.haActiveUser;
  }
  if (!Util.isUnset(request.haActiveVersion)) {
    query['HaActiveVersion'] = request.haActiveVersion;
  }
  if (!Util.isUnset(request.haMigrateType)) {
    query['HaMigrateType'] = request.haMigrateType;
  }
  if (!Util.isUnset(request.haStandby)) {
    query['HaStandby'] = request.haStandby;
  }
  if (!Util.isUnset(request.haStandbyClusterKey)) {
    query['HaStandbyClusterKey'] = request.haStandbyClusterKey;
  }
  if (!Util.isUnset(request.haStandbyDBType)) {
    query['HaStandbyDBType'] = request.haStandbyDBType;
  }
  if (!Util.isUnset(request.haStandbyHbaseFsDir)) {
    query['HaStandbyHbaseFsDir'] = request.haStandbyHbaseFsDir;
  }
  if (!Util.isUnset(request.haStandbyHdfsUri)) {
    query['HaStandbyHdfsUri'] = request.haStandbyHdfsUri;
  }
  if (!Util.isUnset(request.haStandbyPassword)) {
    query['HaStandbyPassword'] = request.haStandbyPassword;
  }
  if (!Util.isUnset(request.haStandbyUser)) {
    query['HaStandbyUser'] = request.haStandbyUser;
  }
  if (!Util.isUnset(request.haStandbyVersion)) {
    query['HaStandbyVersion'] = request.haStandbyVersion;
  }
  if (!Util.isUnset(request.haTables)) {
    query['HaTables'] = request.haTables;
  }
  if (!Util.isUnset(request.isActiveStandard)) {
    query['IsActiveStandard'] = request.isActiveStandard;
  }
  if (!Util.isUnset(request.isStandbyStandard)) {
    query['IsStandbyStandard'] = request.isStandbyStandard;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RelateDbForHBaseHa',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request RelateDbForHBaseHaRequest
 * @return RelateDbForHBaseHaResponse
 */
async function relateDbForHBaseHa(request: RelateDbForHBaseHaRequest): RelateDbForHBaseHaResponse {
  var runtime = new Util.RuntimeOptions{};
  return relateDbForHBaseHaWithOptions(request, runtime);
}

model ReleasePublicNetworkAddressRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn******'),
}

model ReleasePublicNetworkAddressResponseBody = {
  requestId?: string(name='RequestId', example='B18D4390-A968-4444-B323-4360B8E5DA3E'),
}

model ReleasePublicNetworkAddressResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ReleasePublicNetworkAddressResponseBody(name='body'),
}

/**
 * @param request ReleasePublicNetworkAddressRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ReleasePublicNetworkAddressResponse
 */
async function releasePublicNetworkAddressWithOptions(request: ReleasePublicNetworkAddressRequest, runtime: Util.RuntimeOptions): ReleasePublicNetworkAddressResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ReleasePublicNetworkAddress',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ReleasePublicNetworkAddressRequest
 * @return ReleasePublicNetworkAddressResponse
 */
async function releasePublicNetworkAddress(request: ReleasePublicNetworkAddressRequest): ReleasePublicNetworkAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return releasePublicNetworkAddressWithOptions(request, runtime);
}

model RenewInstanceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp1u0639js2h7****'),
  duration?: int32(name='Duration', description='This parameter is required.', example='5'),
  pricingCycle?: string(name='PricingCycle', description='This parameter is required.', example='month'),
}

model RenewInstanceResponseBody = {
  orderId?: long(name='OrderId', example='211235614240728'),
  requestId?: string(name='RequestId', example='729CB2A7-3065-53A9-B27C-7033CA4881D9'),
}

model RenewInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RenewInstanceResponseBody(name='body'),
}

/**
 * @param request RenewInstanceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RenewInstanceResponse
 */
async function renewInstanceWithOptions(request: RenewInstanceRequest, runtime: Util.RuntimeOptions): RenewInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.duration)) {
    query['Duration'] = request.duration;
  }
  if (!Util.isUnset(request.pricingCycle)) {
    query['PricingCycle'] = request.pricingCycle;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RenewInstance',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request RenewInstanceRequest
 * @return RenewInstanceResponse
 */
async function renewInstance(request: RenewInstanceRequest): RenewInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return renewInstanceWithOptions(request, runtime);
}

model ResizeColdStorageSizeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp169l540vc6c****'),
  coldStorageSize?: int32(name='ColdStorageSize', description='This parameter is required.', example='900'),
}

model ResizeColdStorageSizeResponseBody = {
  orderId?: string(name='OrderId', example='21711518427****'),
  requestId?: string(name='RequestId', example='5AA6F80E-535C-5611-BD13-3832D96A4D0E'),
}

model ResizeColdStorageSizeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ResizeColdStorageSizeResponseBody(name='body'),
}

/**
 * @param request ResizeColdStorageSizeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ResizeColdStorageSizeResponse
 */
async function resizeColdStorageSizeWithOptions(request: ResizeColdStorageSizeRequest, runtime: Util.RuntimeOptions): ResizeColdStorageSizeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.coldStorageSize)) {
    query['ColdStorageSize'] = request.coldStorageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ResizeColdStorageSize',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ResizeColdStorageSizeRequest
 * @return ResizeColdStorageSizeResponse
 */
async function resizeColdStorageSize(request: ResizeColdStorageSizeRequest): ResizeColdStorageSizeResponse {
  var runtime = new Util.RuntimeOptions{};
  return resizeColdStorageSizeWithOptions(request, runtime);
}

model ResizeDiskSizeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
  nodeDiskSize?: int32(name='NodeDiskSize', description='This parameter is required.', example='120'),
}

model ResizeDiskSizeResponseBody = {
  orderId?: string(name='OrderId', example='3C22622B-8555-42BF-AD8A-1B960743****'),
  requestId?: string(name='RequestId', example='493A762B-E4A6-44E9-B877-CA6D0CAF8B29'),
}

model ResizeDiskSizeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ResizeDiskSizeResponseBody(name='body'),
}

/**
 * @param request ResizeDiskSizeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ResizeDiskSizeResponse
 */
async function resizeDiskSizeWithOptions(request: ResizeDiskSizeRequest, runtime: Util.RuntimeOptions): ResizeDiskSizeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.nodeDiskSize)) {
    query['NodeDiskSize'] = request.nodeDiskSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ResizeDiskSize',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ResizeDiskSizeRequest
 * @return ResizeDiskSizeResponse
 */
async function resizeDiskSize(request: ResizeDiskSizeRequest): ResizeDiskSizeResponse {
  var runtime = new Util.RuntimeOptions{};
  return resizeDiskSizeWithOptions(request, runtime);
}

model ResizeMultiZoneClusterDiskSizeRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-f5d6vc2r8d6****'),
  coreDiskSize?: int32(name='CoreDiskSize', example='480'),
  logDiskSize?: int32(name='LogDiskSize', example='440'),
}

model ResizeMultiZoneClusterDiskSizeResponseBody = {
  orderId?: string(name='OrderId', example='123412341****'),
  requestId?: string(name='RequestId', example='568339C4-9F71-43D0-994E-E039CD826E56'),
}

model ResizeMultiZoneClusterDiskSizeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ResizeMultiZoneClusterDiskSizeResponseBody(name='body'),
}

/**
 * @param request ResizeMultiZoneClusterDiskSizeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ResizeMultiZoneClusterDiskSizeResponse
 */
async function resizeMultiZoneClusterDiskSizeWithOptions(request: ResizeMultiZoneClusterDiskSizeRequest, runtime: Util.RuntimeOptions): ResizeMultiZoneClusterDiskSizeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.coreDiskSize)) {
    query['CoreDiskSize'] = request.coreDiskSize;
  }
  if (!Util.isUnset(request.logDiskSize)) {
    query['LogDiskSize'] = request.logDiskSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ResizeMultiZoneClusterDiskSize',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ResizeMultiZoneClusterDiskSizeRequest
 * @return ResizeMultiZoneClusterDiskSizeResponse
 */
async function resizeMultiZoneClusterDiskSize(request: ResizeMultiZoneClusterDiskSizeRequest): ResizeMultiZoneClusterDiskSizeResponse {
  var runtime = new Util.RuntimeOptions{};
  return resizeMultiZoneClusterDiskSizeWithOptions(request, runtime);
}

model ResizeMultiZoneClusterNodeCountRequest {
  arbiterVSwitchId?: string(name='ArbiterVSwitchId', example='vsw-hangxzhouxb*****'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-f5d8d6s4s2a1****'),
  coreNodeCount?: int32(name='CoreNodeCount', example='6'),
  logNodeCount?: int32(name='LogNodeCount', example='8'),
  primaryCoreNodeCount?: int32(name='PrimaryCoreNodeCount', example='6'),
  primaryVSwitchId?: string(name='PrimaryVSwitchId', example='vsw-hangxzhouxe*****'),
  standbyCoreNodeCount?: int32(name='StandbyCoreNodeCount', example='6'),
  standbyVSwitchId?: string(name='StandbyVSwitchId', example='vsw-hangxzhouxf****'),
}

model ResizeMultiZoneClusterNodeCountResponseBody = {
  orderId?: string(name='OrderId', example='1234123412****'),
  requestId?: string(name='RequestId', example='E2B7E9DA-1575-4B9D-A0E4-9468BAC'),
}

model ResizeMultiZoneClusterNodeCountResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ResizeMultiZoneClusterNodeCountResponseBody(name='body'),
}

/**
 * @param request ResizeMultiZoneClusterNodeCountRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ResizeMultiZoneClusterNodeCountResponse
 */
async function resizeMultiZoneClusterNodeCountWithOptions(request: ResizeMultiZoneClusterNodeCountRequest, runtime: Util.RuntimeOptions): ResizeMultiZoneClusterNodeCountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.arbiterVSwitchId)) {
    query['ArbiterVSwitchId'] = request.arbiterVSwitchId;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.coreNodeCount)) {
    query['CoreNodeCount'] = request.coreNodeCount;
  }
  if (!Util.isUnset(request.logNodeCount)) {
    query['LogNodeCount'] = request.logNodeCount;
  }
  if (!Util.isUnset(request.primaryCoreNodeCount)) {
    query['PrimaryCoreNodeCount'] = request.primaryCoreNodeCount;
  }
  if (!Util.isUnset(request.primaryVSwitchId)) {
    query['PrimaryVSwitchId'] = request.primaryVSwitchId;
  }
  if (!Util.isUnset(request.standbyCoreNodeCount)) {
    query['StandbyCoreNodeCount'] = request.standbyCoreNodeCount;
  }
  if (!Util.isUnset(request.standbyVSwitchId)) {
    query['StandbyVSwitchId'] = request.standbyVSwitchId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ResizeMultiZoneClusterNodeCount',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ResizeMultiZoneClusterNodeCountRequest
 * @return ResizeMultiZoneClusterNodeCountResponse
 */
async function resizeMultiZoneClusterNodeCount(request: ResizeMultiZoneClusterNodeCountRequest): ResizeMultiZoneClusterNodeCountResponse {
  var runtime = new Util.RuntimeOptions{};
  return resizeMultiZoneClusterNodeCountWithOptions(request, runtime);
}

model ResizeNodeCountRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-bp16o0pd52e3y****'),
  nodeCount?: int32(name='NodeCount', description='This parameter is required.', example='5'),
  vSwitchId?: string(name='VSwitchId', example='vsw-bp191otqj1ssyl****'),
  zoneId?: string(name='ZoneId', example='cn-hangzhou-f'),
}

model ResizeNodeCountResponseBody = {
  orderId?: string(name='OrderId', example='20470860005****'),
  requestId?: string(name='RequestId', example='B288B41F-6681-42A6-8905-47C3C42B19B0'),
}

model ResizeNodeCountResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ResizeNodeCountResponseBody(name='body'),
}

/**
 * @param request ResizeNodeCountRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ResizeNodeCountResponse
 */
async function resizeNodeCountWithOptions(request: ResizeNodeCountRequest, runtime: Util.RuntimeOptions): ResizeNodeCountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.nodeCount)) {
    query['NodeCount'] = request.nodeCount;
  }
  if (!Util.isUnset(request.vSwitchId)) {
    query['VSwitchId'] = request.vSwitchId;
  }
  if (!Util.isUnset(request.zoneId)) {
    query['ZoneId'] = request.zoneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ResizeNodeCount',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request ResizeNodeCountRequest
 * @return ResizeNodeCountResponse
 */
async function resizeNodeCount(request: ResizeNodeCountRequest): ResizeNodeCountResponse {
  var runtime = new Util.RuntimeOptions{};
  return resizeNodeCountWithOptions(request, runtime);
}

model RestartInstanceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  components?: string(name='Components', example='THRIFT'),
}

model RestartInstanceResponseBody = {
  requestId?: string(name='RequestId', example='F744E939-D08D-5623-82C8-9D1F9F7685D1'),
}

model RestartInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RestartInstanceResponseBody(name='body'),
}

/**
 * @param request RestartInstanceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RestartInstanceResponse
 */
async function restartInstanceWithOptions(request: RestartInstanceRequest, runtime: Util.RuntimeOptions): RestartInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.components)) {
    query['Components'] = request.components;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RestartInstance',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request RestartInstanceRequest
 * @return RestartInstanceResponse
 */
async function restartInstance(request: RestartInstanceRequest): RestartInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return restartInstanceWithOptions(request, runtime);
}

model RevokeRequest {
  accountName?: string(name='AccountName', description='This parameter is required.', example='test01'),
  aclActions?: string(name='AclActions', description='This parameter is required.', example='READ,WRITE'),
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-bp150tns0sjxs****'),
  namespace?: string(name='Namespace', description='This parameter is required.', example='default'),
  tableName?: string(name='TableName', description='This parameter is required.', example='table'),
}

model RevokeResponseBody = {
  requestId?: string(name='RequestId', example='C9085433-A56A-4089-B49A-DF5A4E2B7B06'),
}

model RevokeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RevokeResponseBody(name='body'),
}

/**
 * @summary 回收账户权限
 *
 * @param request RevokeRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RevokeResponse
 */
async function revokeWithOptions(request: RevokeRequest, runtime: Util.RuntimeOptions): RevokeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.aclActions)) {
    query['AclActions'] = request.aclActions;
  }
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.namespace)) {
    query['Namespace'] = request.namespace;
  }
  if (!Util.isUnset(request.tableName)) {
    query['TableName'] = request.tableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'Revoke',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 回收账户权限
 *
 * @param request RevokeRequest
 * @return RevokeResponse
 */
async function revoke(request: RevokeRequest): RevokeResponse {
  var runtime = new Util.RuntimeOptions{};
  return revokeWithOptions(request, runtime);
}

model SwitchHbaseHaSlbRequest {
  bdsId?: string(name='BdsId', description='This parameter is required.', example='bds-t4n3496whj23ia4k'),
  haId?: string(name='HaId', description='This parameter is required.', example='ha-v21tmnxjwh2yuy1il'),
  haTypes?: string(name='HaTypes', description='This parameter is required.', example='thrift'),
  hbaseType?: string(name='HbaseType', description='This parameter is required.', example='Active'),
}

model SwitchHbaseHaSlbResponseBody = {
  requestId?: string(name='RequestId', example='C9D568D9-A59C-4AF2-8FBB-F086A841D58E'),
}

model SwitchHbaseHaSlbResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SwitchHbaseHaSlbResponseBody(name='body'),
}

/**
 * @param request SwitchHbaseHaSlbRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SwitchHbaseHaSlbResponse
 */
async function switchHbaseHaSlbWithOptions(request: SwitchHbaseHaSlbRequest, runtime: Util.RuntimeOptions): SwitchHbaseHaSlbResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bdsId)) {
    query['BdsId'] = request.bdsId;
  }
  if (!Util.isUnset(request.haId)) {
    query['HaId'] = request.haId;
  }
  if (!Util.isUnset(request.haTypes)) {
    query['HaTypes'] = request.haTypes;
  }
  if (!Util.isUnset(request.hbaseType)) {
    query['HbaseType'] = request.hbaseType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SwitchHbaseHaSlb',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request SwitchHbaseHaSlbRequest
 * @return SwitchHbaseHaSlbResponse
 */
async function switchHbaseHaSlb(request: SwitchHbaseHaSlbRequest): SwitchHbaseHaSlbResponse {
  var runtime = new Util.RuntimeOptions{};
  return switchHbaseHaSlbWithOptions(request, runtime);
}

model SwitchServiceRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-uf6r2hn2zrxxxxxx'),
  operate?: string(name='Operate', description='This parameter is required.', example='open'),
  serviceName?: string(name='ServiceName', description='This parameter is required.', example='HBaseProxy'),
}

model SwitchServiceResponseBody = {
  requestId?: string(name='RequestId', example='F1005DE4-D981-559F-9E37-5172DXXXXXX'),
}

model SwitchServiceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SwitchServiceResponseBody(name='body'),
}

/**
 * @summary 开通/关闭 扩展服务
 *
 * @param request SwitchServiceRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SwitchServiceResponse
 */
async function switchServiceWithOptions(request: SwitchServiceRequest, runtime: Util.RuntimeOptions): SwitchServiceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.operate)) {
    query['Operate'] = request.operate;
  }
  if (!Util.isUnset(request.serviceName)) {
    query['ServiceName'] = request.serviceName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SwitchService',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 开通/关闭 扩展服务
 *
 * @param request SwitchServiceRequest
 * @return SwitchServiceResponse
 */
async function switchService(request: SwitchServiceRequest): SwitchServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return switchServiceWithOptions(request, runtime);
}

model TagResourcesRequest {
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  resourceId?: [ string ](name='ResourceId', description='This parameter is required.', example='bds-bp15e022622fk0w1'),
  tag?: [ 
    {
      key?: string(name='Key', example='key1'),
      value?: string(name='Value', example='value1'),
    }
  ](name='Tag', description='This parameter is required.'),
}

model TagResourcesResponseBody = {
  requestId?: string(name='RequestId', example='2656FA19-6059-40C8-A157-3FFBEAEC2369'),
}

model TagResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: TagResourcesResponseBody(name='body'),
}

/**
 * @param request TagResourcesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return TagResourcesResponse
 */
async function tagResourcesWithOptions(request: TagResourcesRequest, runtime: Util.RuntimeOptions): TagResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceId)) {
    query['ResourceId'] = request.resourceId;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'TagResources',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request TagResourcesRequest
 * @return TagResourcesResponse
 */
async function tagResources(request: TagResourcesRequest): TagResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return tagResourcesWithOptions(request, runtime);
}

model UnTagResourcesRequest {
  all?: boolean(name='All', example='true'),
  regionId?: string(name='RegionId', description='This parameter is required.', example='cn-hangzhou'),
  resourceId?: [ string ](name='ResourceId', description='This parameter is required.', example='bds-bp15e022622fk0w1'),
  tagKey?: [ string ](name='TagKey', example='key1'),
}

model UnTagResourcesResponseBody = {
  requestId?: string(name='RequestId', example='9CBF8DF0-4931-4A54-9B60-4C6E1AB59286'),
}

model UnTagResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UnTagResourcesResponseBody(name='body'),
}

/**
 * @param request UnTagResourcesRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UnTagResourcesResponse
 */
async function unTagResourcesWithOptions(request: UnTagResourcesRequest, runtime: Util.RuntimeOptions): UnTagResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.all)) {
    query['All'] = request.all;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.resourceId)) {
    query['ResourceId'] = request.resourceId;
  }
  if (!Util.isUnset(request.tagKey)) {
    query['TagKey'] = request.tagKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UnTagResources',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UnTagResourcesRequest
 * @return UnTagResourcesResponse
 */
async function unTagResources(request: UnTagResourcesRequest): UnTagResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return unTagResourcesWithOptions(request, runtime);
}

model UpgradeMinorVersionRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='hb-t4naqsay5gn****'),
  components?: string(name='Components', example='HADOOP'),
}

model UpgradeMinorVersionResponseBody = {
  requestId?: string(name='RequestId', example='7B8EC240-BB13-4DBC-B955-F90170E82609'),
  upgradingComponents?: string(name='UpgradingComponents', example='HADOOP'),
}

model UpgradeMinorVersionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpgradeMinorVersionResponseBody(name='body'),
}

/**
 * @param request UpgradeMinorVersionRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpgradeMinorVersionResponse
 */
async function upgradeMinorVersionWithOptions(request: UpgradeMinorVersionRequest, runtime: Util.RuntimeOptions): UpgradeMinorVersionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.components)) {
    query['Components'] = request.components;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpgradeMinorVersion',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpgradeMinorVersionRequest
 * @return UpgradeMinorVersionResponse
 */
async function upgradeMinorVersion(request: UpgradeMinorVersionRequest): UpgradeMinorVersionResponse {
  var runtime = new Util.RuntimeOptions{};
  return upgradeMinorVersionWithOptions(request, runtime);
}

model UpgradeMultiZoneClusterRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ld-***************'),
  components?: string(name='Components', description='This parameter is required.', example='LINDORM'),
  restartComponents?: string(name='RestartComponents', example='LPROXY'),
  runMode?: string(name='RunMode', example='serial'),
  upgradeInsName?: string(name='UpgradeInsName', example='ld-t4n40m3171t4******-az-b'),
  versions?: string(name='Versions', example='t-apsara-lindorm-2.1.20-20200518175539.alios7.x86_64'),
}

model UpgradeMultiZoneClusterResponseBody = {
  requestId?: string(name='RequestId', example='C532A4D4-9451-4460-BB3E-300FEC852D3F'),
  upgradingComponents?: string(name='UpgradingComponents', example='LINDORM'),
}

model UpgradeMultiZoneClusterResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpgradeMultiZoneClusterResponseBody(name='body'),
}

/**
 * @param request UpgradeMultiZoneClusterRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return UpgradeMultiZoneClusterResponse
 */
async function upgradeMultiZoneClusterWithOptions(request: UpgradeMultiZoneClusterRequest, runtime: Util.RuntimeOptions): UpgradeMultiZoneClusterResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.components)) {
    query['Components'] = request.components;
  }
  if (!Util.isUnset(request.restartComponents)) {
    query['RestartComponents'] = request.restartComponents;
  }
  if (!Util.isUnset(request.runMode)) {
    query['RunMode'] = request.runMode;
  }
  if (!Util.isUnset(request.upgradeInsName)) {
    query['UpgradeInsName'] = request.upgradeInsName;
  }
  if (!Util.isUnset(request.versions)) {
    query['Versions'] = request.versions;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpgradeMultiZoneCluster',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request UpgradeMultiZoneClusterRequest
 * @return UpgradeMultiZoneClusterResponse
 */
async function upgradeMultiZoneCluster(request: UpgradeMultiZoneClusterRequest): UpgradeMultiZoneClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return upgradeMultiZoneClusterWithOptions(request, runtime);
}

model XpackRelateDBRequest {
  clusterId?: string(name='ClusterId', description='This parameter is required.', example='ap-bp1qtz9rcbbt3****'),
  dbClusterIds?: string(name='DbClusterIds', description='This parameter is required.', example='hb-bp16o0pd52e3****'),
  relateDbType?: string(name='RelateDbType', description='This parameter is required.', example='hbase'),
}

model XpackRelateDBResponseBody = {
  requestId?: string(name='RequestId', example='50373857-C47B-4B64-9332-D0B5280B59EA'),
}

model XpackRelateDBResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: XpackRelateDBResponseBody(name='body'),
}

/**
 * @param request XpackRelateDBRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return XpackRelateDBResponse
 */
async function xpackRelateDBWithOptions(request: XpackRelateDBRequest, runtime: Util.RuntimeOptions): XpackRelateDBResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clusterId)) {
    query['ClusterId'] = request.clusterId;
  }
  if (!Util.isUnset(request.dbClusterIds)) {
    query['DbClusterIds'] = request.dbClusterIds;
  }
  if (!Util.isUnset(request.relateDbType)) {
    query['RelateDbType'] = request.relateDbType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'XpackRelateDB',
    version = '2019-01-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @param request XpackRelateDBRequest
 * @return XpackRelateDBResponse
 */
async function xpackRelateDB(request: XpackRelateDBRequest): XpackRelateDBResponse {
  var runtime = new Util.RuntimeOptions{};
  return xpackRelateDBWithOptions(request, runtime);
}

